@secondlayer/stacks 5.1.3 → 6.1.0

package/dist/src/index.cjs

@@ -1,3 +1,727 @@
+var import_node_module = require("node:module");
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/filters/index.ts
+var exports_filters = {};
+__export(exports_filters, {
+  on: () => on,
+  makeChainEventFilter: () => makeChainEventFilter,
+  isPrincipal: () => isPrincipal,
+  hasWildcard: () => hasWildcard,
+  fromSubgraphSource: () => fromSubgraphSource,
+  assetId: () => assetId,
+  assertPrincipalish: () => assertPrincipalish,
+  assertContractId: () => assertContractId,
+  assertAssetIdentifier: () => assertAssetIdentifier,
+  VM_NODE_TO_STORED_TYPE: () => VM_NODE_TO_STORED_TYPE,
+  VM_EVENT_TYPES: () => VM_EVENT_TYPES,
+  DECODED_EVENT_TYPES: () => DECODED_EVENT_TYPES,
+  CHAIN_EVENT_FILTER_TYPES: () => CHAIN_EVENT_FILTER_TYPES
+});
+module.exports = __toCommonJS(exports_filters);
+
+// src/filters/event-types.ts
+var DECODED_EVENT_TYPES = [
+  "stx_transfer",
+  "stx_mint",
+  "stx_burn",
+  "stx_lock",
+  "ft_transfer",
+  "ft_mint",
+  "ft_burn",
+  "nft_transfer",
+  "nft_mint",
+  "nft_burn",
+  "print"
+];
+var VM_EVENT_TYPES = [
+  "nested_contract_call",
+  "var_set",
+  "map_set",
+  "map_insert",
+  "map_delete"
+];
+var VM_NODE_TO_STORED_TYPE = {
+  contract_call_event: "nested_contract_call",
+  var_set_event: "var_set",
+  map_set_event: "map_set",
+  map_insert_event: "map_insert",
+  map_delete_event: "map_delete"
+};
+var CHAIN_EVENT_FILTER_TYPES = [
+  "stx_transfer",
+  "stx_mint",
+  "stx_burn",
+  "stx_lock",
+  "ft_transfer",
+  "ft_mint",
+  "ft_burn",
+  "nft_transfer",
+  "nft_mint",
+  "nft_burn",
+  "contract_call",
+  "contract_deploy",
+  "print_event",
+  "nested_contract_call",
+  "var_set",
+  "map_set",
+  "map_insert",
+  "map_delete",
+  "sbtc_deposit",
+  "sbtc_withdrawal_create",
+  "sbtc_withdrawal_accept",
+  "sbtc_withdrawal_reject",
+  "sbtc_withdrawal_swept_confirmed"
+];
+// src/utils/c32.ts
+var import_sha2 = require("@noble/hashes/sha2.js");
+
+// src/utils/encoding.ts
+var hexes = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+function bytesToHex(bytes) {
+  let hex = "";
+  for (const b of bytes) {
+    hex += hexes[b];
+  }
+  return hex;
+}
+function hexToBytes(hex) {
+  let h = without0x(hex);
+  if (h.length % 2)
+    h = `0${h}`;
+  const array = new Uint8Array(h.length / 2);
+  for (let i = 0;i < array.length; i++) {
+    const j = i * 2;
+    const byte = Number.parseInt(h.slice(j, j + 2), 16);
+    if (Number.isNaN(byte) || byte < 0)
+      throw new Error("Invalid byte sequence");
+    array[i] = byte;
+  }
+  return array;
+}
+function with0x(value) {
+  return /^0x/i.test(value) ? value : `0x${value}`;
+}
+function without0x(value) {
+  return /^0x/i.test(value) ? value.slice(2) : value;
+}
+function utf8ToBytes(str) {
+  return new TextEncoder().encode(str);
+}
+function bytesToUtf8(bytes) {
+  return new TextDecoder().decode(bytes);
+}
+function asciiToBytes(str) {
+  const bytes = new Uint8Array(str.length);
+  for (let i = 0;i < str.length; i++) {
+    bytes[i] = str.charCodeAt(i) & 255;
+  }
+  return bytes;
+}
+function bytesToAscii(bytes) {
+  return String.fromCharCode(...bytes);
+}
+function concatBytes(...arrays) {
+  if (arrays.length === 1)
+    return arrays[0];
+  const length = arrays.reduce((a, arr) => a + arr.length, 0);
+  const result = new Uint8Array(length);
+  let pad = 0;
+  for (const arr of arrays) {
+    result.set(arr, pad);
+    pad += arr.length;
+  }
+  return result;
+}
+function intToBigInt(value) {
+  if (typeof value === "bigint")
+    return value;
+  if (typeof value === "string")
+    return BigInt(value);
+  if (typeof value === "number") {
+    if (!Number.isInteger(value))
+      throw new RangeError("Values of type 'number' must be an integer.");
+    if (value > Number.MAX_SAFE_INTEGER)
+      throw new RangeError(`Values of type 'number' must be <= ${Number.MAX_SAFE_INTEGER}. Use BigInt instead.`);
+    return BigInt(value);
+  }
+  if (value instanceof Uint8Array)
+    return BigInt(`0x${bytesToHex(value)}`);
+  throw new TypeError("Must be a number, bigint, string, or Uint8Array.");
+}
+function intToBytes(value, byteLength) {
+  return bigIntToBytes(intToBigInt(value), byteLength);
+}
+function bigIntToBytes(value, length = 16) {
+  const hex = value.toString(16).padStart(length * 2, "0");
+  return hexToBytes(hex);
+}
+function intToHex(integer, byteLength = 8) {
+  const value = typeof integer === "bigint" ? integer : intToBigInt(integer);
+  return value.toString(16).padStart(byteLength * 2, "0");
+}
+function toTwos(value, width) {
+  const limit = BigInt(1) << width - BigInt(1);
+  if (value < -limit || value > limit - BigInt(1)) {
+    throw new Error(`Unable to represent integer in width: ${width}`);
+  }
+  if (value >= BigInt(0))
+    return value;
+  return value + (BigInt(1) << width);
+}
+function fromTwos(value, width) {
+  if (value & BigInt(1) << width - BigInt(1)) {
+    return value - (BigInt(1) << width);
+  }
+  return value;
+}
+function bytesToTwosBigInt(bytes) {
+  if (bytes.length === 0)
+    return 0n;
+  const hex = bytesToHex(bytes);
+  if (hex.length === 0)
+    return 0n;
+  return fromTwos(BigInt(`0x${hex}`), BigInt(bytes.byteLength * 8));
+}
+function writeUInt32BE(value) {
+  const buf = new Uint8Array(4);
+  buf[0] = value >>> 24 & 255;
+  buf[1] = value >>> 16 & 255;
+  buf[2] = value >>> 8 & 255;
+  buf[3] = value & 255;
+  return buf;
+}
+function readUInt32BE(bytes, offset = 0) {
+  return (bytes[offset] << 24 | bytes[offset + 1] << 16 | bytes[offset + 2] << 8 | bytes[offset + 3]) >>> 0;
+}
+function writeUInt16BE(value) {
+  const buf = new Uint8Array(2);
+  buf[0] = value >>> 8 & 255;
+  buf[1] = value & 255;
+  return buf;
+}
+function readUInt16BE(bytes, offset = 0) {
+  return (bytes[offset] << 8 | bytes[offset + 1]) >>> 0;
+}
+function writeUInt8(value) {
+  return new Uint8Array([value & 255]);
+}
+
+// src/utils/c32.ts
+var C32 = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+var HEX = "0123456789abcdef";
+function c32normalize(input) {
+  return input.toUpperCase().replace(/O/g, "0").replace(/L|I/g, "1");
+}
+function c32encode(inputHex) {
+  let hex = inputHex;
+  if (hex.length % 2 !== 0)
+    hex = `0${hex}`;
+  hex = hex.toLowerCase();
+  const res = [];
+  let carry = 0;
+  for (let i = hex.length - 1;i >= 0; i--) {
+    if (carry < 4) {
+      const currentCode = HEX.indexOf(hex[i]) >> carry;
+      const nextCode = i !== 0 ? HEX.indexOf(hex[i - 1]) : 0;
+      const nextBits = 1 + carry;
+      const nextLowBits = nextCode % (1 << nextBits) << 5 - nextBits;
+      res.unshift(C32[currentCode + nextLowBits]);
+      carry = nextBits;
+    } else {
+      carry = 0;
+    }
+  }
+  let leadingZeros = 0;
+  while (leadingZeros < res.length && res[leadingZeros] === "0")
+    leadingZeros++;
+  const stripped = res.slice(leadingZeros);
+  const bytes = hexToBytes(hex);
+  let zeroBytesCount = 0;
+  while (zeroBytesCount < bytes.length && bytes[zeroBytesCount] === 0)
+    zeroBytesCount++;
+  const prefix = Array(zeroBytesCount).fill(C32[0]);
+  return [...prefix, ...stripped].join("");
+}
+function c32decode(c32input) {
+  const input = c32normalize(c32input);
+  if (!input.match(`^[${C32}]*$`))
+    throw new Error("Not a c32-encoded string");
+  const zeroPrefix = input.match(`^${C32[0]}*`);
+  const numLeadingZeroBytes = zeroPrefix ? zeroPrefix[0]?.length : 0;
+  const res = [];
+  let carry = 0;
+  let carryBits = 0;
+  for (let i = input.length - 1;i >= 0; i--) {
+    if (carryBits === 4) {
+      res.unshift(HEX[carry]);
+      carryBits = 0;
+      carry = 0;
+    }
+    const currentValue = (C32.indexOf(input[i]) << carryBits) + carry;
+    res.unshift(HEX[currentValue % 16]);
+    carryBits += 1;
+    carry = currentValue >> 4;
+    if (carry > 1 << carryBits)
+      throw new Error("Panic error in c32 decoding");
+  }
+  res.unshift(HEX[carry]);
+  if (res.length % 2 === 1)
+    res.unshift("0");
+  let hexLeadingZeros = 0;
+  while (hexLeadingZeros < res.length && res[hexLeadingZeros] === "0")
+    hexLeadingZeros++;
+  let hexStr = res.slice(hexLeadingZeros - hexLeadingZeros % 2).join("");
+  for (let i = 0;i < numLeadingZeroBytes; i++)
+    hexStr = `00${hexStr}`;
+  return hexStr;
+}
+function c32checksum(dataHex) {
+  return bytesToHex(import_sha2.sha256(import_sha2.sha256(hexToBytes(dataHex))).slice(0, 4));
+}
+function c32checkEncode(version, data) {
+  if (version < 0 || version >= 32)
+    throw new Error("Invalid version (must be between 0 and 31)");
+  if (!data.match(/^[0-9a-fA-F]*$/))
+    throw new Error("Invalid data (not a hex string)");
+  let d = data.toLowerCase();
+  if (d.length % 2 !== 0)
+    d = `0${d}`;
+  let versionHex = version.toString(16);
+  if (versionHex.length === 1)
+    versionHex = `0${versionHex}`;
+  const checksumHex = c32checksum(`${versionHex}${d}`);
+  return `${C32[version]}${c32encode(`${d}${checksumHex}`)}`;
+}
+function c32checkDecode(c32data) {
+  const normalized = c32normalize(c32data);
+  const dataHex = c32decode(normalized.slice(1));
+  const version = C32.indexOf(normalized[0]);
+  const checksum = dataHex.slice(-8);
+  let versionHex = version.toString(16);
+  if (versionHex.length === 1)
+    versionHex = `0${versionHex}`;
+  if (c32checksum(`${versionHex}${dataHex.substring(0, dataHex.length - 8)}`) !== checksum) {
+    throw new Error("Invalid c32check string: checksum mismatch");
+  }
+  return [version, dataHex.substring(0, dataHex.length - 8)];
+}
+function c32address(version, hash160hex) {
+  if (!hash160hex.match(/^[0-9a-fA-F]{40}$/)) {
+    throw new Error("Invalid argument: not a hash160 hex string");
+  }
+  return `S${c32checkEncode(version, hash160hex)}`;
+}
+function c32addressDecode(c32addr) {
+  if (c32addr.length <= 5)
+    throw new Error("Invalid c32 address: invalid length");
+  if (c32addr[0] !== "S")
+    throw new Error('Invalid c32 address: must start with "S"');
+  return c32checkDecode(c32addr.slice(1));
+}
+
+// src/utils/constants.ts
+var MAX_U128 = (1n << 128n) - 1n;
+var MAX_I128 = (1n << 127n) - 1n;
+var MIN_I128 = -(1n << 127n);
+var AddressVersion = {
+  MainnetSingleSig: 22,
+  MainnetMultiSig: 20,
+  TestnetSingleSig: 26,
+  TestnetMultiSig: 21
+};
+var ZERO_ADDRESS = "SP000000000000000000002Q6VF78";
+var TESTNET_ZERO_ADDRESS = "ST000000000000000000002AMW42H";
+var MICROSTX_PER_STX = 1000000n;
+
+// src/utils/hash.ts
+var import_legacy = require("@noble/hashes/legacy.js");
+var import_sha22 = require("@noble/hashes/sha2.js");
+var import_sha23 = require("@noble/hashes/sha2.js");
+function hash160(input) {
+  return import_legacy.ripemd160(import_sha22.sha256(input));
+}
+function txidFromBytes(data) {
+  return bytesToHex(import_sha23.sha512_256(data));
+}
+function hashP2PKH(input) {
+  return bytesToHex(hash160(input));
+}
+
+// src/utils/address.ts
+function publicKeyToAddress(publicKey, network = "mainnet") {
+  const bytes = typeof publicKey === "string" ? hexToBytes(without0x(publicKey)) : publicKey;
+  const version = network === "mainnet" ? AddressVersion.MainnetSingleSig : AddressVersion.TestnetSingleSig;
+  return c32address(version, bytesToHex(hash160(bytes)));
+}
+var CONTRACT_NAME_REGEX = /^[a-zA-Z][a-zA-Z0-9_-]{0,127}$/;
+function validateStacksAddress(address) {
+  try {
+    c32addressDecode(address);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var isValidAddress = validateStacksAddress;
+function parsePrincipal(value) {
+  const parts = value.split(".");
+  if (parts.length > 2)
+    return null;
+  const [address, contractName] = parts;
+  if (!validateStacksAddress(address))
+    return null;
+  if (contractName === undefined)
+    return { address };
+  if (!CONTRACT_NAME_REGEX.test(contractName))
+    return null;
+  return { address, contractName };
+}
+function parseContractId(contractId) {
+  const parsed = parsePrincipal(contractId);
+  if (!parsed?.contractName)
+    throw new Error(`Invalid contract identifier: ${contractId}`);
+  return [parsed.address, parsed.contractName];
+}
+function isClarityName(name) {
+  const regex = /^[a-zA-Z]([a-zA-Z0-9]|[-_!?+<>=/*])*$|^[-+=/*]$|^[<>]=?$/;
+  return regex.test(name) && name.length < 128;
+}
+function isAddressEqual(a, b) {
+  const [versionA, hashA] = c32addressDecode(a);
+  const [versionB, hashB] = c32addressDecode(b);
+  return versionA === versionB && hashA.toLowerCase() === hashB.toLowerCase();
+}
+function addressToVersion(address) {
+  return c32addressDecode(address)[0];
+}
+function getContractAddress(deployer, contractName) {
+  if (!validateStacksAddress(deployer)) {
+    throw new Error(`Invalid deployer address: ${deployer}`);
+  }
+  if (!isClarityName(contractName)) {
+    throw new Error(`Invalid contract name: ${contractName}`);
+  }
+  return `${deployer}.${contractName}`;
+}
+
+// src/filters/validate.ts
+function assetId(value) {
+  assertAssetIdentifier("assetIdentifier", value);
+  return value;
+}
+function isPrincipal(value) {
+  return parsePrincipal(value) !== null;
+}
+function hasWildcard(value) {
+  return value.includes("*");
+}
+function assertPrincipalish(field, value) {
+  if (hasWildcard(value))
+    return;
+  if (!isPrincipal(value)) {
+    throw new Error(`${field} "${value}" is not a valid Stacks principal (SP…/ST…, optionally .contract-name).`);
+  }
+}
+function assertAssetIdentifier(field, value) {
+  if (hasWildcard(value))
+    return;
+  const [contractId, assetName, ...rest] = value.split("::");
+  if (!contractId || !assetName || rest.length > 0 || !contractId.includes(".") || !isPrincipal(contractId)) {
+    throw new Error(`${field} "${value}" is not a valid asset identifier (SP….contract-name::asset-name). Passing a bare contract id here matches zero rows — use contractId for that.`);
+  }
+}
+function assertContractId(field, value) {
+  if (hasWildcard(value))
+    return;
+  if (value.includes("::")) {
+    throw new Error(`${field} "${value}" is an asset identifier, not a contract id — use assetIdentifier for that.`);
+  }
+  if (!value.includes(".") || !isPrincipal(value)) {
+    throw new Error(`${field} "${value}" is not a valid contract id (SP….contract-name).`);
+  }
+}
+
+// src/filters/factories.ts
+var PRINCIPAL_FIELDS = new Set([
+  "sender",
+  "recipient",
+  "caller",
+  "deployer",
+  "lockedAddress"
+]);
+var AMOUNT_FIELDS = new Set(["minAmount", "maxAmount"]);
+var DECORATIVE_FIELDS = new Set(["abi", "prints"]);
+function specEntries(spec) {
+  return Object.entries(spec).filter(([key, value]) => key !== "type" && value !== undefined);
+}
+function validateSpec(spec) {
+  for (const [key, value] of specEntries(spec)) {
+    if (PRINCIPAL_FIELDS.has(key)) {
+      assertPrincipalish(key, value);
+    } else if (key === "assetIdentifier") {
+      assertAssetIdentifier(key, value);
+    } else if (key === "contractId") {
+      for (const id of Array.isArray(value) ? value : [value]) {
+        assertContractId(key, id);
+      }
+    }
+  }
+}
+function unsupported(surface, field, hint) {
+  throw new Error(`${field} cannot be expressed on ${surface} — ${hint}. Drop the field from the filter or use the surface that supports it.`);
+}
+function assertNoWildcards(surface, spec) {
+  for (const [key, value] of specEntries(spec)) {
+    const candidates = Array.isArray(value) ? value : [value];
+    for (const candidate of candidates) {
+      if (typeof candidate === "string" && hasWildcard(candidate)) {
+        unsupported(surface, `${key} wildcard "${candidate}"`, "wildcard patterns are Webhooks/Subgraphs-only");
+      }
+    }
+  }
+}
+function assertNotTraitAndContract(surface, spec) {
+  const trait = "trait" in spec ? spec.trait : undefined;
+  const contract = "contractId" in spec ? spec.contractId : undefined;
+  if (trait !== undefined && contract !== undefined) {
+    unsupported(surface, "trait with contractId", "the Index treats them as mutually exclusive — drop one, or use a subgraph source, which ANDs the pair");
+  }
+}
+function toChainTrigger(spec) {
+  const out = {};
+  for (const [key, value] of specEntries(spec)) {
+    if (DECORATIVE_FIELDS.has(key))
+      continue;
+    if (key === "factory") {
+      unsupported("Webhooks", "factory", "dynamic factory discovery is a Subgraphs-only concept — a trigger targets addresses known when it is created");
+    }
+    if (Array.isArray(value)) {
+      unsupported("Webhooks", `${key} set`, "a chain trigger targets ONE contract — create one subscription per contract, or use Index/Subgraphs which accept the set");
+    }
+    out[key] = typeof value === "bigint" ? value.toString() : value;
+  }
+  return { type: spec.type, ...out };
+}
+function toIndexParams(spec, extra = {}) {
+  assertNoWildcards("Index events", spec);
+  assertNotTraitAndContract("Index events", spec);
+  const out = {
+    eventType: spec.type === "print_event" ? "print" : spec.type
+  };
+  for (const [key, value] of specEntries(spec)) {
+    if (DECORATIVE_FIELDS.has(key))
+      continue;
+    if (key === "factory") {
+      unsupported("Index events", "factory", "dynamic factory discovery is a Subgraphs-only concept");
+    }
+    if (AMOUNT_FIELDS.has(key)) {
+      unsupported("Index events", key, "amount predicates are Webhooks/Subgraphs-only; filter client-side on the decoded rows");
+    }
+    if (key === "topic") {
+      unsupported("Index events", "topic", "per-topic reads are Subgraphs/Webhooks-only (or read the contract's print feed and switch on topic)");
+    }
+    if (key === "lockedAddress") {
+      out.sender = value;
+      continue;
+    }
+    if (key === "caller" && spec.type !== "nested_contract_call") {
+      unsupported("Index events", "caller", "outer contract-call fields live on index.contractCalls");
+    }
+    out[key] = value;
+  }
+  return { ...out, ...extra };
+}
+var VM_MEMBERS = new Set([
+  "nested_contract_call",
+  "var_set",
+  "map_set",
+  "map_insert",
+  "map_delete"
+]);
+var VM_INDEX_ONLY_FIELDS = new Set([
+  "functionName",
+  "caller",
+  "sender",
+  "map",
+  "varName"
+]);
+function toStreamsParams(spec, extra = {}) {
+  assertNoWildcards("Streams", spec);
+  const out = {
+    types: [spec.type === "print_event" ? "print" : spec.type]
+  };
+  const isVm = VM_MEMBERS.has(spec.type);
+  if (isVm)
+    out.clock = "vm";
+  for (const [key, value] of specEntries(spec)) {
+    if (DECORATIVE_FIELDS.has(key))
+      continue;
+    if (isVm && VM_INDEX_ONLY_FIELDS.has(key)) {
+      unsupported("Streams", key, "vm payload predicates are Index/Subgraphs/Subscriptions-only; Streams clock=vm narrows by types and contractId");
+    }
+    if (key === "factory") {
+      unsupported("Streams", "factory", "dynamic factory discovery is a Subgraphs-only concept");
+    }
+    if (AMOUNT_FIELDS.has(key)) {
+      unsupported("Streams", key, "amount predicates are Webhooks/Subgraphs-only");
+    }
+    if (key === "trait") {
+      unsupported("Streams", "trait", "Streams has no trait resolution — Index and Subgraphs do");
+    }
+    if (key === "topic") {
+      unsupported("Streams", "topic", "per-topic filtering is Subgraphs/Webhooks-only");
+    }
+    if (key === "lockedAddress") {
+      unsupported("Streams", "lockedAddress", "stx_lock address filtering is Webhooks/Subgraphs-only");
+    }
+    out[key] = value;
+  }
+  return { ...out, ...extra };
+}
+function toContractCallsParams(spec, extra = {}) {
+  assertNoWildcards("Index contract-calls", spec);
+  assertNotTraitAndContract("Index contract-calls", spec);
+  const out = {};
+  for (const [key, value] of specEntries(spec)) {
+    if (DECORATIVE_FIELDS.has(key))
+      continue;
+    if (key === "factory") {
+      unsupported("Index contract-calls", "factory", "dynamic factory discovery is a Subgraphs-only concept");
+    }
+    if (key === "caller") {
+      out.sender = value;
+      continue;
+    }
+    out[key] = value;
+  }
+  return { ...out, ...extra };
+}
+function toSubgraphSource(spec) {
+  return Object.fromEntries([
+    ["type", spec.type],
+    ...specEntries(spec)
+  ]);
+}
+var DECODED_MEMBERS = new Set([
+  "stx_transfer",
+  "stx_mint",
+  "stx_burn",
+  "stx_lock",
+  "ft_transfer",
+  "ft_mint",
+  "ft_burn",
+  "nft_transfer",
+  "nft_mint",
+  "nft_burn",
+  "print_event"
+]);
+function makeChainEventFilter(type, fields) {
+  const spec = { type, ...fields };
+  validateSpec(spec);
+  const filter = { ...spec };
+  filter.toChainTrigger = () => toChainTrigger(spec);
+  if (DECODED_MEMBERS.has(type) || VM_MEMBERS.has(type)) {
+    filter.toIndexParams = (extra) => toIndexParams(spec, extra);
+    filter.toStreamsParams = (extra) => toStreamsParams(spec, extra);
+  }
+  if (type === "contract_call") {
+    filter.toContractCallsParams = (extra) => toContractCallsParams(spec, extra);
+  }
+  if (!type.startsWith("sbtc_")) {
+    filter.toSubgraphSource = () => toSubgraphSource(spec);
+  }
+  return filter;
+}
+function fromSubgraphSource(source) {
+  const { type, ...fields } = source;
+  return makeChainEventFilter(type, fields);
+}
+var on = {
+  stxTransfer: (fields = {}) => makeChainEventFilter("stx_transfer", fields),
+  stxMint: (fields = {}) => makeChainEventFilter("stx_mint", fields),
+  stxBurn: (fields = {}) => makeChainEventFilter("stx_burn", fields),
+  stxLock: (fields = {}) => makeChainEventFilter("stx_lock", fields),
+  ftTransfer: (fields = {}) => makeChainEventFilter("ft_transfer", fields),
+  ftMint: (fields = {}) => makeChainEventFilter("ft_mint", fields),
+  ftBurn: (fields = {}) => makeChainEventFilter("ft_burn", fields),
+  nftTransfer: (fields = {}) => makeChainEventFilter("nft_transfer", fields),
+  nftMint: (fields = {}) => makeChainEventFilter("nft_mint", fields),
+  nftBurn: (fields = {}) => makeChainEventFilter("nft_burn", fields),
+  contractCall: (fields = {}) => makeChainEventFilter("contract_call", fields),
+  contractDeploy: (fields = {}) => makeChainEventFilter("contract_deploy", fields),
+  print: (fields = {}) => makeChainEventFilter("print_event", fields),
+  nestedCall: (fields = {}) => makeChainEventFilter("nested_contract_call", fields),
+  varSet: (fields = {}) => makeChainEventFilter("var_set", fields),
+  mapSet: (fields = {}) => makeChainEventFilter("map_set", fields),
+  mapInsert: (fields = {}) => makeChainEventFilter("map_insert", fields),
+  mapDelete: (fields = {}) => makeChainEventFilter("map_delete", fields),
+  sbtcDeposit: (fields = {}) => makeChainEventFilter("sbtc_deposit", fields),
+  sbtcWithdrawalCreate: (fields = {}) => makeChainEventFilter("sbtc_withdrawal_create", fields),
+  sbtcWithdrawalAccept: (fields = {}) => makeChainEventFilter("sbtc_withdrawal_accept", fields),
+  sbtcWithdrawalReject: (fields = {}) => makeChainEventFilter("sbtc_withdrawal_reject", fields),
+  sbtcWithdrawalSweptConfirmed: (fields = {}) => makeChainEventFilter("sbtc_withdrawal_swept_confirmed", fields)
+};
 // src/index.ts
 var exports_src = {};
 __export(exports_src, {
@@ -64,77 +788,3100 @@ __export(exports_src, {
 });
 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;
+// 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");
+  }
+}
+function serializeCV(value) {
+  return bytesToHex(serializeCVBytes(value));
+}
+
+// src/transactions/types.ts
+var AuthType = {
+  Standard: 4,
+  Sponsored: 5
+};
+var PayloadType = {
+  TokenTransfer: 0,
+  SmartContract: 1,
+  ContractCall: 2,
+  PoisonMicroblock: 3,
+  Coinbase: 4,
+  CoinbaseToAltRecipient: 5,
+  VersionedSmartContract: 6,
+  TenureChange: 7,
+  NakamotoCoinbase: 8
+};
+var ClarityVersion = {
+  Clarity1: 1,
+  Clarity2: 2,
+  Clarity3: 3,
+  Clarity4: 4,
+  Clarity5: 5,
+  Clarity6: 6
+};
+var AnchorMode = {
+  OnChainOnly: 1,
+  OffChainOnly: 2,
+  Any: 3
+};
+var PostConditionModeWire = {
+  Allow: 1,
+  Deny: 2,
+  Originator: 3
+};
+var AddressHashMode = {
+  P2PKH: 0,
+  P2SH: 1,
+  P2WPKH: 2,
+  P2WSH: 3,
+  P2SH_NonSequential: 5,
+  P2WSH_P2SH_NonSequential: 7
+};
+var PubKeyEncoding = {
+  Compressed: 0,
+  Uncompressed: 1
+};
+var FungibleConditionCode = {
+  Equal: 1,
+  Greater: 2,
+  GreaterEqual: 3,
+  Less: 4,
+  LessEqual: 5
+};
+var NonFungibleConditionCode = {
+  Sends: 16,
+  DoesNotSend: 17,
+  MaybeSent: 18
+};
+var PoxConditionCode = {
+  WillNotPerform: 48,
+  MayPerform: 49,
+  WillPerform: 50
+};
+var PostConditionPrincipalId = {
+  Origin: 1,
+  Standard: 2,
+  Contract: 3
+};
+var AssetType = {
+  STX: 0,
+  Fungible: 1,
+  NonFungible: 2,
+  Staking: 3,
+  Pox: 4
+};
+var AuthFieldType = {
+  PublicKeyCompressed: 0,
+  PublicKeyUncompressed: 1,
+  SignatureCompressed: 2,
+  SignatureUncompressed: 3
+};
+var RECOVERABLE_ECDSA_SIG_LENGTH_BYTES = 65;
+var MEMO_MAX_LENGTH_BYTES = 34;
+var MAX_STRING_LENGTH_BYTES = 128;
+var COINBASE_BYTES_LENGTH = 32;
+var VRF_PROOF_BYTES_LENGTH = 80;
+var MICROBLOCK_HEADER_BYTES_LENGTH = 132;
+var TenureChangeCause = {
+  BlockFound: 0,
+  Extended: 1,
+  ExtendedRuntime: 2,
+  ExtendedReadCount: 3,
+  ExtendedReadLength: 4,
+  ExtendedWriteCount: 5,
+  ExtendedWriteLength: 6
+};
+
+// src/transactions/wire/serialize.ts
+function serializeAddress2(c32Address) {
+  const [version, hash1602] = c32addressDecode(c32Address);
+  return concatBytes(new Uint8Array([version]), hexToBytes(hash1602));
+}
+function serializeLPString2(str, prefixBytes = 1) {
+  const content = utf8ToBytes(str);
+  const prefix = hexToBytes(intToHex(content.byteLength, prefixBytes));
+  return concatBytes(prefix, content);
+}
+function serializeLPStringLong(str) {
+  return serializeLPString2(str, 4);
+}
+function serializeMemo(memo) {
+  const content = asciiToBytes(memo);
+  const padded = new Uint8Array(MEMO_MAX_LENGTH_BYTES);
+  padded.set(content.slice(0, MEMO_MAX_LENGTH_BYTES));
+  return padded;
+}
+function serializeSpendingCondition(condition) {
+  const parts = [
+    writeUInt8(condition.hashMode),
+    hexToBytes(condition.signer),
+    intToBytes(condition.nonce, 8),
+    intToBytes(condition.fee, 8)
+  ];
+  if ("signature" in condition) {
+    const sc = condition;
+    parts.push(writeUInt8(sc.keyEncoding));
+    parts.push(hexToBytes(sc.signature));
+  } else {
+    const mc = condition;
+    parts.push(writeUInt32BE(mc.fields.length));
+    for (const field of mc.fields) {
+      parts.push(serializeAuthField(field));
+    }
+    parts.push(writeUInt16BE(mc.signaturesRequired));
+  }
+  return concatBytes(...parts);
+}
+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 ? 2 : 3;
+  return concatBytes(writeUInt8(typeId), hexToBytes(field.data));
+}
+function serializeAuthorization(auth) {
+  const parts = [writeUInt8(auth.authType)];
+  parts.push(serializeSpendingCondition(auth.spendingCondition));
+  if (auth.authType === AuthType.Sponsored) {
+    parts.push(serializeSpendingCondition(auth.sponsorSpendingCondition));
+  }
+  return concatBytes(...parts);
+}
+function serializePrincipal(principal) {
+  switch (principal.type) {
+    case "origin":
+      return writeUInt8(PostConditionPrincipalId.Origin);
+    case "standard":
+      return concatBytes(writeUInt8(PostConditionPrincipalId.Standard), serializeAddress2(principal.address));
+    case "contract":
+      return concatBytes(writeUInt8(PostConditionPrincipalId.Contract), serializeAddress2(principal.address), serializeLPString2(principal.contractName));
+  }
+}
+function serializeAssetInfo(asset) {
+  return concatBytes(serializeAddress2(asset.address), serializeLPString2(asset.contractName), serializeLPString2(asset.assetName));
+}
+function serializePostConditionWire(pc) {
+  const parts = [];
+  switch (pc.type) {
+    case "stx":
+      parts.push(writeUInt8(AssetType.STX));
+      parts.push(serializePrincipal(pc.principal));
+      parts.push(writeUInt8(pc.conditionCode));
+      parts.push(intToBytes(pc.amount, 8));
+      break;
+    case "ft":
+      parts.push(writeUInt8(AssetType.Fungible));
+      parts.push(serializePrincipal(pc.principal));
+      parts.push(serializeAssetInfo(pc.asset));
+      parts.push(writeUInt8(pc.conditionCode));
+      parts.push(intToBytes(pc.amount, 8));
+      break;
+    case "nft":
+      parts.push(writeUInt8(AssetType.NonFungible));
+      parts.push(serializePrincipal(pc.principal));
+      parts.push(serializeAssetInfo(pc.asset));
+      parts.push(serializeCVBytes(pc.assetId));
+      parts.push(writeUInt8(pc.conditionCode));
+      break;
+    case "staking":
+      parts.push(writeUInt8(AssetType.Staking));
+      parts.push(serializePrincipal(pc.principal));
+      parts.push(writeUInt8(pc.conditionCode));
+      parts.push(intToBytes(pc.amount, 8));
+      break;
+    case "pox":
+      parts.push(writeUInt8(AssetType.Pox));
+      parts.push(serializePrincipal(pc.principal));
+      parts.push(writeUInt8(pc.conditionCode));
+      break;
+  }
+  return concatBytes(...parts);
+}
+function serializePostConditions(pcs) {
+  const parts = [writeUInt32BE(pcs.length)];
+  for (const pc of pcs)
+    parts.push(serializePostConditionWire(pc));
+  return concatBytes(...parts);
+}
+function serializePayload(payload) {
+  const parts = [writeUInt8(payload.payloadType)];
+  switch (payload.payloadType) {
+    case PayloadType.TokenTransfer:
+      parts.push(serializeCVBytes(payload.recipient));
+      parts.push(intToBytes(payload.amount, 8));
+      parts.push(serializeMemo(payload.memo));
+      break;
+    case PayloadType.ContractCall:
+      parts.push(serializeAddress2(payload.contractAddress));
+      parts.push(serializeLPString2(payload.contractName));
+      parts.push(serializeLPString2(payload.functionName));
+      parts.push(writeUInt32BE(payload.functionArgs.length));
+      for (const arg of payload.functionArgs) {
+        parts.push(serializeCVBytes(arg));
+      }
+      break;
+    case PayloadType.SmartContract:
+      parts.push(serializeLPString2(payload.contractName));
+      parts.push(serializeLPStringLong(payload.codeBody));
+      break;
+    case PayloadType.VersionedSmartContract:
+      parts.push(writeUInt8(payload.clarityVersion ?? 2));
+      parts.push(serializeLPString2(payload.contractName));
+      parts.push(serializeLPStringLong(payload.codeBody));
+      break;
+    case PayloadType.Coinbase:
+      parts.push(hexToBytes(payload.coinbaseBuffer));
+      break;
+    case PayloadType.CoinbaseToAltRecipient: {
+      const cbAlt = payload;
+      parts.push(hexToBytes(cbAlt.coinbaseBuffer));
+      parts.push(serializeCVBytes(cbAlt.recipient));
+      break;
+    }
+    case PayloadType.PoisonMicroblock: {
+      const pm = payload;
+      parts.push(hexToBytes(pm.header1));
+      parts.push(hexToBytes(pm.header2));
+      break;
+    }
+    case PayloadType.TenureChange: {
+      const tc = payload;
+      parts.push(hexToBytes(tc.tenureConsensusHash));
+      parts.push(hexToBytes(tc.prevTenureConsensusHash));
+      parts.push(hexToBytes(tc.burnViewConsensusHash));
+      parts.push(hexToBytes(tc.previousTenureEnd));
+      parts.push(writeUInt32BE(tc.previousTenureBlocks));
+      parts.push(writeUInt8(tc.cause));
+      parts.push(hexToBytes(tc.pubkeyHash));
+      break;
+    }
+    case PayloadType.NakamotoCoinbase: {
+      const nc = payload;
+      parts.push(hexToBytes(nc.coinbaseBuffer));
+      if (nc.recipient) {
+        parts.push(serializeCVBytes({ type: "some", value: nc.recipient }));
+      } else {
+        parts.push(serializeCVBytes({ type: "none" }));
+      }
+      parts.push(hexToBytes(nc.vrfProof));
+      break;
+    }
+  }
+  return concatBytes(...parts);
+}
+var _txCache = new WeakMap;
+function clearTxCache(tx) {
+  _txCache.delete(tx);
+}
+function serializeTransaction(tx) {
+  const cached = _txCache.get(tx);
+  if (cached)
+    return cached;
+  const bytes = concatBytes(writeUInt8(tx.version), writeUInt32BE(tx.chainId), serializeAuthorization(tx.auth), writeUInt8(tx.anchorMode), writeUInt8(tx.postConditionMode), serializePostConditions(tx.postConditions), serializePayload(tx.payload));
+  _txCache.set(tx, bytes);
+  return bytes;
+}
+function serializeTransactionHex(tx) {
+  return bytesToHex(serializeTransaction(tx));
+}
+
+// src/actions/public/estimateFee.ts
+function isValidEstimation(e) {
+  return typeof e === "object" && e !== null && "fee_rate" in e && "fee" in e && (typeof e.fee_rate === "number" || typeof e.fee_rate === "string") && (typeof e.fee === "number" || typeof e.fee === "string");
+}
+async function estimateFee(client, params) {
+  const payloadHex = bytesToHex(serializePayload(params.transaction.payload));
+  const txHex = bytesToHex(serializeTransaction(params.transaction));
+  const data = await client.request("/v2/fees/transaction", {
+    method: "POST",
+    body: {
+      estimated_len: Math.ceil(txHex.length / 2),
+      transaction_payload: `0x${payloadHex}`
+    }
+  });
+  const raw = data?.estimations ?? [];
+  return raw.map((e) => {
+    if (!isValidEstimation(e)) {
+      throw new MalformedResponseError("estimateFee: node response contains invalid fee estimation entry");
+    }
+    return {
+      feeRate: Number(e.fee_rate),
+      fee: Number(e.fee)
+    };
+  });
+}
+
+// src/actions/public/getAccountHistory.ts
+async function getAccountHistory(client, params) {
+  const limit = Math.min(params.limit ?? 20, 50);
+  return client.request(`/extended/v2/addresses/${encodeURIComponent(params.address)}/transactions?limit=${limit}`, { method: "GET" });
+}
+
+// src/actions/public/getAccountInfo.ts
+async function getAccountInfo(client, params) {
+  const data = await client.request(`/v2/accounts/${encodeURIComponent(params.address)}?proof=1`, { method: "GET" });
+  const balance = data?.balance;
+  const nonce = data?.nonce;
+  if (typeof balance !== "string" && typeof balance !== "number" || typeof nonce !== "string" && typeof nonce !== "number") {
+    throw new MalformedResponseError(`getAccountInfo: /v2/accounts/${params.address} response is missing "balance" or "nonce"`);
+  }
+  return {
+    balance: BigInt(balance),
+    nonce: BigInt(nonce),
+    balanceProof: data.balance_proof ?? "",
+    nonceProof: data.nonce_proof ?? ""
+  };
+}
+
+// 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/actions/public/getContractAbi.ts
+async function getContractAbi(client, params) {
+  const [address, name] = parseContractId(params.contract);
+  return client.request(`/v2/contracts/interface/${address}/${name}`, {
+    method: "GET"
+  });
+}
+
+// src/errors/http.ts
+class HttpRequestError extends BaseError {
+  name = "HttpRequestError";
+  status;
+  url;
+  method;
+  constructor(status, options) {
+    const where = options?.url !== undefined ? ` (${options.method ?? "GET"} ${options.url})` : "";
+    super(`HTTP request failed with status ${status}${where}`, options);
+    this.status = status;
+    this.url = options?.url;
+    this.method = options?.method;
+  }
+}
+
+// src/actions/public/getContractSource.ts
+async function getContractSource(client, params) {
+  const [address, name] = parseContractId(params.contract);
+  try {
+    const data = await client.request(`/v2/contracts/source/${address}/${name}`, { method: "GET" });
+    return data?.source ? data : null;
+  } catch (error) {
+    if (error instanceof HttpRequestError && error.status === 404)
+      return null;
+    throw error;
+  }
+}
+
+// src/errors/transaction.ts
+class TransactionError extends BaseError {
+  name = "TransactionError";
+}
+
+class BroadcastError extends BaseError {
+  name = "BroadcastError";
+  txid;
+  reason;
+  reasonData;
+  constructor(message, options) {
+    super(message, options);
+    this.txid = options?.txid;
+    this.reason = options?.reason;
+    this.reasonData = options?.reasonData;
+  }
+}
+
+class TransactionAbortedError extends BaseError {
+  name = "TransactionAbortedError";
+  receipt;
+  constructor(message, options) {
+    super(message, options);
+    this.receipt = options.receipt;
+  }
+}
+
+class TransactionDroppedError extends BaseError {
+  name = "TransactionDroppedError";
+  txid;
+  constructor(message, options) {
+    super(message, options);
+    this.txid = options.txid;
+  }
+}
+
+class WaitForTransactionTimeoutError extends BaseError {
+  name = "WaitForTransactionTimeoutError";
+  txid;
+  constructor(message, options) {
+    super(message, options);
+    this.txid = options.txid;
+  }
+}
+
+class SerializationError extends BaseError {
+  name = "SerializationError";
+}
+
+class SigningError extends BaseError {
+  name = "SigningError";
+}
+
+// src/utils/bytes-reader.ts
+class BytesReader {
+  data;
+  offset = 0;
+  constructor(data) {
+    this.data = data;
+  }
+  remaining() {
+    return this.data.length - this.offset;
+  }
+  ensure(length) {
+    if (this.offset + length > this.data.length) {
+      throw new SerializationError(`Buffer underflow: need ${length} bytes at offset ${this.offset}, have ${this.data.length}`);
+    }
+  }
+  readUInt8() {
+    this.ensure(1);
+    return this.data[this.offset++];
+  }
+  readUInt16BE() {
+    this.ensure(2);
+    const val = (this.data[this.offset] << 8 | this.data[this.offset + 1]) >>> 0;
+    this.offset += 2;
+    return val;
+  }
+  readUInt32BE() {
+    this.ensure(4);
+    const val = (this.data[this.offset] << 24 | this.data[this.offset + 1] << 16 | this.data[this.offset + 2] << 8 | this.data[this.offset + 3]) >>> 0;
+    this.offset += 4;
+    return val;
+  }
+  readBytes(length) {
+    this.ensure(length);
+    const slice = this.data.slice(this.offset, this.offset + length);
+    this.offset += length;
+    return slice;
+  }
+  readBigUInt64BE() {
+    const hex = bytesToHex(this.readBytes(8));
+    return hex.length > 0 ? BigInt(`0x${hex}`) : 0n;
+  }
+}
+
+// src/clarity/values.ts
+var MAX_U1282 = BigInt("0xffffffffffffffffffffffffffffffff");
+var MIN_I1282 = BigInt("-170141183460469231731687303715884105728");
+var MAX_I1282 = BigInt("0x7fffffffffffffffffffffffffffffff");
+function intCV(value) {
+  let v = value;
+  if (typeof v === "string" && v.toLowerCase().startsWith("0x")) {
+    v = bytesToTwosBigInt(hexToBytes(v));
+  }
+  if (v instanceof Uint8Array)
+    v = bytesToTwosBigInt(v);
+  const n = intToBigInt(v);
+  if (n > MAX_I1282)
+    throw new RangeError(`Int exceeds max i128: ${MAX_I1282}`);
+  if (n < MIN_I1282)
+    throw new RangeError(`Int below min i128: ${MIN_I1282}`);
+  return { type: "int", value: n };
+}
+function uintCV(value) {
+  const n = intToBigInt(value);
+  if (n < 0n)
+    throw new RangeError("Cannot construct unsigned int from negative value");
+  if (n > MAX_U1282)
+    throw new RangeError(`UInt exceeds max u128: ${MAX_U1282}`);
+  return { type: "uint", value: n };
+}
+var trueCV = () => ({ type: "true" });
+var falseCV = () => ({ type: "false" });
+var boolCV = (v) => v ? trueCV() : falseCV();
+function bufferCV(buffer) {
+  if (buffer.byteLength > 1048576) {
+    throw new Error("Buffer exceeds max size of 1MB");
+  }
+  return { type: "buffer", value: bytesToHex(buffer) };
+}
+function standardPrincipalCV(address) {
+  const [version, hash1602] = c32addressDecode(address);
+  const normalized = c32address(version, hash1602);
+  return { type: "address", value: normalized };
+}
+function contractPrincipalCV(address, contractName) {
+  const [version, hash1602] = c32addressDecode(address);
+  const normalized = c32address(version, hash1602);
+  if (utf8ToBytes(contractName).byteLength >= 128) {
+    throw new Error("Contract name must be less than 128 bytes");
+  }
+  return { type: "contract", value: `${normalized}.${contractName}` };
+}
+function noneCV() {
+  return { type: "none" };
+}
+function someCV(value) {
+  return { type: "some", value };
+}
+function responseOkCV(value) {
+  return { type: "ok", value };
+}
+function responseErrorCV(value) {
+  return { type: "err", value };
+}
+function listCV(values) {
+  return { type: "list", value: values };
+}
+function tupleCV(data) {
+  for (const key in data) {
+    if (!isClarityName(key)) {
+      throw new Error(`"${key}" is not a valid Clarity name`);
+    }
+  }
+  return { type: "tuple", value: data };
+}
+function stringAsciiCV(value) {
+  return { type: "ascii", value };
+}
+function stringUtf8CV(value) {
+  return { type: "utf8", value };
+}
+var Cl = {
+  int: intCV,
+  uint: uintCV,
+  bool: boolCV,
+  principal(address) {
+    const parsed = parsePrincipal(address);
+    if (!parsed)
+      throw new Error(`Invalid principal: ${address}`);
+    return parsed.contractName ? contractPrincipalCV(parsed.address, parsed.contractName) : standardPrincipalCV(parsed.address);
+  },
+  address(address) {
+    return Cl.principal(address);
+  },
+  contractPrincipal: contractPrincipalCV,
+  standardPrincipal: standardPrincipalCV,
+  buffer: bufferCV,
+  bufferFromHex: (hex) => bufferCV(hexToBytes(hex)),
+  bufferFromAscii: (ascii) => bufferCV(asciiToBytes(ascii)),
+  bufferFromUtf8: (utf8) => bufferCV(utf8ToBytes(utf8)),
+  none: noneCV,
+  some: someCV,
+  ok: responseOkCV,
+  error: responseErrorCV,
+  list: listCV,
+  tuple: tupleCV,
+  stringAscii: stringAsciiCV,
+  stringUtf8: stringUtf8CV,
+  serialize(value) {
+    return bytesToHex(serializeCVBytes(value));
+  },
+  deserialize: deserializeCVBytes
+};
+
+// src/clarity/deserialize.ts
+function readAddress(reader) {
+  const version = reader.readUInt8();
+  const hash1602 = bytesToHex(reader.readBytes(20));
+  return c32address(version, hash1602);
+}
+function readLPString(reader, prefixBytes = 1) {
+  let length = 0;
+  for (let i = 0;i < prefixBytes; i++) {
+    length = length << 8 | reader.readUInt8();
+  }
+  return bytesToUtf8(reader.readBytes(length));
+}
+var MAX_CV_DEPTH = 64;
+var MIN_LIST_ITEM_BYTES = 1;
+var MIN_TUPLE_ENTRY_BYTES = 2;
+function checkCount(reader, count, minBytes) {
+  if (count * minBytes > reader.remaining()) {
+    throw new SerializationError(`Clarity value declares ${count} elements but only ${reader.remaining()} bytes remain`);
+  }
+}
+function readCV(reader, depth = 0) {
+  if (depth > MAX_CV_DEPTH) {
+    throw new SerializationError(`Clarity value nests deeper than ${MAX_CV_DEPTH} levels`);
+  }
+  const typeByte = reader.readUInt8();
+  const type = clarityTypeFromByte(typeByte);
+  switch (type) {
+    case "int":
+      return intCV(bytesToTwosBigInt(reader.readBytes(16)));
+    case "uint":
+      return uintCV(reader.readBytes(16));
+    case "true":
+      return trueCV();
+    case "false":
+      return falseCV();
+    case "buffer": {
+      const len = reader.readUInt32BE();
+      return bufferCV(reader.readBytes(len));
+    }
+    case "none":
+      return noneCV();
+    case "some":
+      return someCV(readCV(reader, depth + 1));
+    case "ok":
+      return responseOkCV(readCV(reader, depth + 1));
+    case "err":
+      return responseErrorCV(readCV(reader, depth + 1));
+    case "address":
+      return standardPrincipalCV(readAddress(reader));
+    case "contract": {
+      const addr = readAddress(reader);
+      const name = readLPString(reader);
+      return contractPrincipalCV(addr, name);
+    }
+    case "list": {
+      const len = reader.readUInt32BE();
+      checkCount(reader, len, MIN_LIST_ITEM_BYTES);
+      const items = [];
+      for (let i = 0;i < len; i++) {
+        items.push(readCV(reader, depth + 1));
+      }
+      return listCV(items);
+    }
+    case "tuple": {
+      const len = reader.readUInt32BE();
+      checkCount(reader, len, MIN_TUPLE_ENTRY_BYTES);
+      const data = {};
+      for (let i = 0;i < len; i++) {
+        const key = readLPString(reader);
+        data[key] = readCV(reader, depth + 1);
+      }
+      return tupleCV(data);
+    }
+    case "ascii": {
+      const len = reader.readUInt32BE();
+      return stringAsciiCV(bytesToAscii(reader.readBytes(len)));
+    }
+    case "utf8": {
+      const len = reader.readUInt32BE();
+      return stringUtf8CV(bytesToUtf8(reader.readBytes(len)));
+    }
+    default:
+      throw new SerializationError(`Cannot deserialize unknown clarity type: ${type}`);
+  }
+}
+function deserializeCVBytes(input) {
+  const bytes = typeof input === "string" ? hexToBytes(without0x(input)) : input;
+  return readCV(new BytesReader(bytes));
+}
+function deserializeCV(input) {
+  return deserializeCVBytes(input);
+}
+
+// src/actions/public/getDataVar.ts
+async function getDataVar(client, params) {
+  const [address, name] = parseContractId(params.contract);
+  const path = `/v2/data_var/${address}/${name}/${params.varName}?proof=0`;
+  const data = await client.request(path, { method: "GET" });
+  if (typeof data?.data !== "string") {
+    throw new MalformedResponseError(`getDataVar: /v2/data_var/${address}/${name}/${params.varName} response is missing "data"`);
+  }
+  return deserializeCVBytes(data.data);
+}
+
+// src/actions/public/getMapEntry.ts
+async function getMapEntry(client, params) {
+  const [address, name] = parseContractId(params.contract);
+  const serializedKey = with0x(bytesToHex(serializeCVBytes(params.key)));
+  const data = await client.request(`/v2/map_entry/${address}/${name}/${params.mapName}`, {
+    method: "POST",
+    body: serializedKey
+  });
+  if (typeof data?.data !== "string") {
+    throw new MalformedResponseError(`getMapEntry: /v2/map_entry/${address}/${name}/${params.mapName} response is missing "data"`);
+  }
+  return deserializeCVBytes(data.data);
+}
+
+// src/actions/public/getMempoolStats.ts
+async function getMempoolStats(client) {
+  return client.request("/extended/v1/tx/mempool/stats", { method: "GET" });
+}
+
+// src/actions/public/getNftHoldings.ts
+async function getNftHoldings(client, params) {
+  const limit = Math.min(params.limit ?? 20, 50);
+  return client.request(`/extended/v1/tokens/nft/holdings?principal=${encodeURIComponent(params.address)}&limit=${limit}`, { method: "GET" });
+}
+
+// src/actions/public/getNonce.ts
+async function getNonce(client, params) {
+  const data = await client.request(`/v2/accounts/${encodeURIComponent(params.address)}`, { method: "GET" });
+  const nonce = data?.nonce;
+  if (typeof nonce !== "number" && typeof nonce !== "string") {
+    throw new MalformedResponseError(`getNonce: /v2/accounts/${params.address} response is missing "nonce"`);
+  }
+  return BigInt(nonce);
+}
+
+// src/actions/public/getRawBlock.ts
+async function getRawBlock(client, params) {
+  try {
+    const data = await client.request(`/v2/blocks/${params.height}`, {
+      method: "GET"
+    });
+    return data?.hash ? data : null;
+  } catch (error) {
+    if (error instanceof HttpRequestError && error.status === 404)
+      return null;
+    throw error;
+  }
+}
+
+// src/errors/transport.ts
+class TimeoutError extends BaseError {
+  name = "TimeoutError";
+  method;
+  url;
+  timeout;
+  attempt;
+  constructor(params) {
+    super(`${params.method} ${params.url} did not complete within ${params.timeout}ms (attempt ${params.attempt + 1})`);
+    this.method = params.method;
+    this.url = params.url;
+    this.timeout = params.timeout;
+    this.attempt = params.attempt;
+  }
+}
+
+// src/transports/createTransport.ts
+function createTransport(type, config) {
+  const { request, apiKey: _apiKey, ...exposed } = config;
+  return {
+    type,
+    request,
+    config: exposed
+  };
+}
+var MAX_ERROR_DETAILS_BYTES = 4096;
+function capDetails(body) {
+  if (body === undefined)
+    return;
+  const bytes = new TextEncoder().encode(body);
+  if (bytes.length <= MAX_ERROR_DETAILS_BYTES)
+    return body;
+  const head = new TextDecoder().decode(bytes.subarray(0, MAX_ERROR_DETAILS_BYTES));
+  return `${head}... [truncated ${bytes.length - MAX_ERROR_DETAILS_BYTES} bytes]`;
+}
+function isRetryableStatus(status) {
+  return status === 429 || status >= 500;
+}
+var MAX_RETRY_AFTER_MS = 60000;
+function retryAfterMs(response) {
+  const value = response.headers.get("Retry-After");
+  if (!value)
+    return;
+  const seconds = Number(value);
+  const ms = Number.isFinite(seconds) ? seconds * 1000 : Date.parse(value) - Date.now();
+  if (!Number.isFinite(ms) || ms < 0 || ms > MAX_RETRY_AFTER_MS)
+    return;
+  return ms;
+}
+function abortReason(signal) {
+  const reason = signal.reason;
+  if (reason instanceof Error)
+    return reason;
+  return new DOMException(typeof reason === "string" ? reason : "The operation was aborted", "AbortError");
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted)
+      return reject(abortReason(signal));
+    const onAbort = () => {
+      clearTimeout(id);
+      reject(abortReason(signal));
+    };
+    const id = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function fetchWithRetry(url, options, retryCount, retryDelay, timeout, extra = {}) {
+  const { signal } = extra;
+  const read = extra.read ?? (async (response) => response);
+  const method = options.method ?? "GET";
+  let lastError;
+  for (let attempt = 0;attempt <= retryCount; attempt++) {
+    if (signal?.aborted)
+      throw abortReason(signal);
+    const controller = new AbortController;
+    let timedOut = false;
+    const timeoutId = setTimeout(() => {
+      timedOut = true;
+      controller.abort(new TimeoutError({ method, url, timeout, attempt }));
+    }, timeout);
+    const onCallerAbort = () => controller.abort(abortReason(signal));
+    signal?.addEventListener("abort", onCallerAbort, { once: true });
+    const aborted = new Promise((_, reject) => {
+      if (controller.signal.aborted)
+        return reject(controller.signal.reason);
+      controller.signal.addEventListener("abort", () => reject(controller.signal.reason), { once: true });
+    });
+    let response;
+    try {
+      try {
+        response = await Promise.race([
+          fetch(url, { ...options, signal: controller.signal }),
+          aborted
+        ]);
+      } catch (error) {
+        if (signal?.aborted)
+          throw abortReason(signal);
+        lastError = timedOut ? new TimeoutError({ method, url, timeout, attempt }) : error instanceof Error ? error : new Error(String(error));
+        if (attempt < retryCount) {
+          clearTimeout(timeoutId);
+          await sleep(retryDelay * (attempt + 1), signal);
+          continue;
+        }
+        throw lastError;
+      }
+      if (response.ok) {
+        try {
+          return await Promise.race([read(response), aborted]);
+        } catch (error) {
+          response.body?.cancel().catch(() => {});
+          if (signal?.aborted)
+            throw abortReason(signal);
+          if (!timedOut)
+            throw error;
+          lastError = new TimeoutError({ method, url, timeout, attempt });
+          if (attempt < retryCount) {
+            clearTimeout(timeoutId);
+            await sleep(retryDelay * (attempt + 1), signal);
+            continue;
+          }
+          throw lastError;
+        }
+      }
+      const retryable = isRetryableStatus(response.status);
+      if (!retryable || attempt === retryCount) {
+        const body = await Promise.race([
+          response.text().catch(() => {
+            return;
+          }),
+          aborted.catch(() => {
+            return;
+          })
+        ]);
+        throw new HttpRequestError(response.status, {
+          details: capDetails(body),
+          url,
+          method
+        });
+      }
+      lastError = new HttpRequestError(response.status, { url, method });
+      const delay = retryAfterMs(response) ?? retryDelay * (attempt + 1);
+      response.body?.cancel().catch(() => {});
+      clearTimeout(timeoutId);
+      await sleep(delay, signal);
+    } finally {
+      clearTimeout(timeoutId);
+      signal?.removeEventListener("abort", onCallerAbort);
+    }
+  }
+  throw lastError ?? new Error("Request failed");
+}
+async function readBody(response) {
+  const contentType = response.headers.get("content-type") ?? "";
+  if (contentType.includes("application/json")) {
+    return response.json();
+  }
+  return response.text();
+}
+function buildRequestFn(baseUrl, config) {
+  const {
+    timeout = 30000,
+    retryCount = 3,
+    retryDelay = 150,
+    fetchOptions = {},
+    apiKey
+  } = config;
+  return async (path, options) => {
+    const url = `${baseUrl.replace(/\/$/, "")}${path}`;
+    const headers = {
+      "Content-Type": "application/json",
+      ...fetchOptions.headers,
+      ...options?.headers
+    };
+    if (apiKey) {
+      headers["x-api-key"] = apiKey;
+    }
+    const init = {
+      ...fetchOptions,
+      method: options?.method ?? "GET",
+      headers
+    };
+    if (options?.body !== undefined) {
+      init.body = JSON.stringify(options.body);
+    }
+    return fetchWithRetry(url, init, options?.retryCount ?? retryCount, retryDelay, timeout, { signal: options?.signal, read: readBody });
+  };
+}
+
+// src/actions/public/txSources.ts
+class IndexSourceConfigError extends Error {
+  name = "IndexSourceConfigError";
+}
+function isHiroHost(url, client) {
+  let hostname;
+  try {
+    hostname = new URL(url).hostname;
+  } catch {
+    return false;
+  }
+  if (hostname === "hiro.so" || hostname.endsWith(".hiro.so"))
+    return true;
+  const defaults = client.chain?.rpcUrls?.default?.http ?? [];
+  return defaults.some((d) => {
+    try {
+      return new URL(d).hostname === hostname && hostname !== "localhost";
+    } catch {
+      return false;
+    }
+  });
+}
+function indexRequestFn(client, baseUrl, sourceName) {
+  const transportUrl = client.transport.config.url?.replace(/\/$/, "");
+  if (baseUrl === undefined) {
+    if (!transportUrl) {
+      throw new IndexSourceConfigError(`${sourceName} needs the URL of your Secondlayer instance: pass baseUrl, or use an http() transport pointed at the instance`);
+    }
+    if (isHiroHost(transportUrl, client)) {
+      throw new IndexSourceConfigError(`${sourceName} reads /v1/index on a Secondlayer instance, and ${transportUrl} is a Hiro host: pass baseUrl with the URL of your instance`);
+    }
+    return client.request;
+  }
+  const target = baseUrl.replace(/\/$/, "");
+  if (target === transportUrl)
+    return client.request;
+  const { timeout, retryCount, retryDelay } = client.transport.config;
+  return buildRequestFn(target, { timeout, retryCount, retryDelay });
+}
+function indexNotFound(error, sourceName) {
+  if (!(error instanceof HttpRequestError) || error.status !== 404) {
+    return false;
+  }
+  const body = error.details;
+  if (body !== undefined) {
+    try {
+      JSON.parse(body);
+    } catch {
+      throw new IndexSourceConfigError(`${sourceName} got a non-JSON 404 from ${error.url ?? "the transport host"}: it does not serve /v1/index, pass baseUrl with the URL of your Secondlayer instance`, { cause: error });
+    }
+  }
+  return true;
+}
+function normalizeTxid(txid) {
+  return txid.startsWith("0x") ? txid : `0x${txid}`;
+}
+function decodeResultHex(hex) {
+  if (!hex)
+    return {};
+  try {
+    return { result: deserializeCVBytes(hex), resultHex: hex };
+  } catch {
+    return { resultHex: hex };
+  }
+}
+function normalizeStatus(txStatus) {
+  switch (txStatus) {
+    case "pending":
+    case "success":
+    case "abort_by_response":
+    case "abort_by_post_condition":
+      return txStatus;
+    default:
+      return txStatus.startsWith("dropped") ? "dropped" : undefined;
+  }
+}
+function extendedApiSource() {
+  return {
+    async get({ client, txid }) {
+      let data;
+      try {
+        data = await client.request(`/extended/v1/tx/${encodeURIComponent(normalizeTxid(txid))}`, { method: "GET" });
+      } catch (error) {
+        if (error instanceof HttpRequestError && error.status === 404) {
+          return { receipt: null };
+        }
+        throw error;
+      }
+      const txStatus = typeof data?.tx_status === "string" ? data.tx_status : undefined;
+      if (!txStatus)
+        return { receipt: null };
+      const status = normalizeStatus(txStatus);
+      if (!status)
+        return { receipt: null };
+      return {
+        receipt: {
+          txid: normalizeTxid(txid),
+          status,
+          blockHeight: typeof data.block_height === "number" && data.block_height > 0 ? data.block_height : undefined,
+          blockHash: data.block_hash ?? undefined,
+          ...decodeResultHex(data.tx_result?.hex),
+          events: Array.isArray(data.events) ? data.events : [],
+          raw: data
+        }
+      };
+    }
+  };
+}
+function indexTxSource(params = {}) {
+  const headers = params.apiKey ? { authorization: `Bearer ${params.apiKey}` } : undefined;
+  return {
+    canonicalOnly: true,
+    async get({ client, txid }) {
+      const request = indexRequestFn(client, params.baseUrl, "indexTxSource");
+      let data;
+      try {
+        data = await request(`/v1/index/transactions/${normalizeTxid(txid)}`, {
+          method: "GET",
+          headers
+        });
+      } catch (error) {
+        if (indexNotFound(error, "indexTxSource"))
+          return { receipt: null };
+        throw error;
+      }
+      const tx = data.transaction;
+      const tip = data.tip?.block_height;
+      if (!tx)
+        return { receipt: null, tip };
+      const status = normalizeStatus(tx.status) ?? "success";
+      return {
+        receipt: {
+          txid: normalizeTxid(tx.tx_id),
+          status,
+          blockHeight: tx.block_height,
+          ...decodeResultHex(tx.contract_call?.result_hex),
+          events: [],
+          raw: data
+        },
+        tip
+      };
+    }
+  };
+}
+
+// src/actions/public/getTransaction.ts
+async function getTransaction(client, params) {
+  const source = params.source ?? extendedApiSource();
+  const { receipt } = await source.get({ client, txid: params.txid });
+  return receipt;
+}
+
+// src/actions/public/readContract.ts
+async function readContract(client, params) {
+  const [address, name] = parseContractId(params.contract);
+  const sender = params.sender ?? address;
+  const serializedArgs = (params.args ?? []).map((arg) => with0x(bytesToHex(serializeCVBytes(arg))));
+  const path = `/v2/contracts/call-read/${encodeURIComponent(address)}/${encodeURIComponent(name)}/${encodeURIComponent(params.functionName)}`;
+  const data = await client.request(params.tip ? `${path}?tip=${encodeURIComponent(params.tip)}` : path, {
+    method: "POST",
+    body: {
+      sender,
+      arguments: serializedArgs
+    }
+  });
+  if (data.okay) {
+    if (typeof data.result !== "string") {
+      throw new MalformedResponseError(`readContract: /v2/contracts/call-read response is missing "result"`);
+    }
+    return deserializeCVBytes(data.result);
+  }
+  throw new ReadContractError(data.cause ?? "Read-only call failed");
+}
+
+// src/actions/public/multicall.ts
+async function mapWithConcurrency(items, limit, fn) {
+  const results = new Array(items.length);
+  let cursor = 0;
+  const worker = async () => {
+    while (cursor < items.length) {
+      const index = cursor++;
+      try {
+        results[index] = {
+          status: "fulfilled",
+          value: await fn(items[index])
+        };
+      } catch (reason) {
+        results[index] = { status: "rejected", reason };
+      }
+    }
+  };
+  const workers = Math.max(1, Math.min(limit, items.length));
+  await Promise.all(Array.from({ length: workers }, worker));
+  return results;
+}
+async function multicall(client, params) {
+  const { calls, allowFailure = true, concurrency = 8 } = params;
+  if (!Number.isInteger(concurrency) || concurrency < 1) {
+    throw new RangeError(`multicall concurrency must be a positive integer, got ${concurrency}`);
+  }
+  const settled = await mapWithConcurrency(calls, concurrency, (call) => readContract(client, call));
+  if (allowFailure) {
+    return settled.map((r) => r.status === "fulfilled" ? { status: "success", result: r.value } : {
+      status: "failure",
+      error: r.reason instanceof Error ? r.reason : new Error(String(r.reason))
+    });
+  }
+  const results = [];
+  for (const r of settled) {
+    if (r.status === "rejected")
+      throw r.reason;
+    results.push(r.value);
+  }
+  return results;
+}
+
+// src/errors/simulation.ts
+class SimulationError extends BaseError {
+  name = "SimulationError";
+  writesDetected;
+  constructor(message, options) {
+    super(message, { details: options.details });
+    this.writesDetected = options.writesDetected;
+  }
+}
+
+// src/actions/public/simulateCall.ts
+async function simulateCall(client, params) {
+  const [address, name] = parseContractId(params.contract);
+  const sender = params.sender ?? address;
+  const serializedArgs = (params.args ?? []).map((arg) => with0x(bytesToHex(serializeCVBytes(arg))));
+  let path = `/v2/contracts/call-read/${address}/${name}/${params.functionName}`;
+  if (params.tip) {
+    path += `?tip=${params.tip}`;
+  }
+  const data = await client.request(path, {
+    method: "POST",
+    body: {
+      sender,
+      arguments: serializedArgs
+    }
+  });
+  if (data.okay) {
+    return { success: true, result: deserializeCVBytes(data.result) };
+  }
+  const cause = data.cause ?? "Simulation failed";
+  const writesDetected = cause.includes("NotReadOnly") || cause.includes("CostBalanceExceeded");
+  return {
+    success: false,
+    error: new SimulationError(writesDetected ? "Function mutates state and cannot be simulated" : "Simulation failed", { writesDetected, details: cause })
+  };
+}
+
+// src/actions/public/simulateTransaction.ts
+function isMultiSig(hashMode) {
+  return hashMode === AddressHashMode.P2SH || hashMode === AddressHashMode.P2WSH || hashMode === AddressHashMode.P2SH_NonSequential || hashMode === AddressHashMode.P2WSH_P2SH_NonSequential;
+}
+function extractSender(tx, client) {
+  const { hashMode, signer } = tx.auth.spendingCondition;
+  const chain = client.chain;
+  const version = isMultiSig(hashMode) ? chain?.addressVersion.multiSig ?? 20 : chain?.addressVersion.singleSig ?? 22;
+  return c32address(version, signer);
+}
+async function simulateTransaction(client, params) {
+  const { transaction, tip } = params;
+  const { payload } = transaction;
+  if (payload.payloadType === PayloadType.ContractCall) {
+    const sender = params.sender ?? extractSender(transaction, client);
+    const contract = `${payload.contractAddress}.${payload.contractName}`;
+    const [execution, fees2] = await Promise.all([
+      simulateCall(client, {
+        contract,
+        functionName: payload.functionName,
+        args: payload.functionArgs,
+        sender,
+        tip
+      }),
+      estimateFee(client, { transaction })
+    ]);
+    return { type: "contract-call", execution, fees: fees2 };
+  }
+  const fees = await estimateFee(client, { transaction });
+  if (payload.payloadType === PayloadType.SmartContract || payload.payloadType === PayloadType.VersionedSmartContract) {
+    return { type: "contract-deploy", fees };
+  }
+  return { type: "token-transfer", fees };
+}
+
+// src/actions/public/waitForTransactionReceipt.ts
+var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
+async function waitForTransactionReceipt(client, params) {
+  const {
+    txid,
+    confirmations = 1,
+    timeout = 180000,
+    pollingInterval = 3000
+  } = params;
+  const source = params.source ?? extendedApiSource();
+  const droppedGracePeriod = params.droppedGracePeriod ?? (source.canonicalOnly ? timeout : 30000);
+  const startedAt = Date.now();
+  let unknownSince = null;
+  let everPending = false;
+  while (true) {
+    const snapshot = await source.get({ client, txid });
+    const receipt = snapshot.receipt;
+    if (receipt === null) {
+      unknownSince ??= Date.now();
+      if (Date.now() - unknownSince >= droppedGracePeriod) {
+        throw new TransactionDroppedError(everPending ? `Transaction ${txid} left the mempool without being mined` : `Transaction ${txid} was never observed by the status source`, { txid });
+      }
+    } else {
+      unknownSince = null;
+      switch (receipt.status) {
+        case "dropped":
+          throw new TransactionDroppedError(`Transaction ${txid} was dropped from the mempool`, { txid });
+        case "abort_by_response":
+        case "abort_by_post_condition":
+          throw new TransactionAbortedError(`Transaction ${txid} aborted (${receipt.status})`, { receipt });
+        case "pending":
+          everPending = true;
+          break;
+        case "success": {
+          if (confirmations <= 1)
+            return receipt;
+          if (receipt.blockHeight !== undefined) {
+            const tip = snapshot.tip ?? await getBlockHeight(client);
+            if (tip - receipt.blockHeight + 1 >= confirmations)
+              return receipt;
+          }
+          break;
+        }
+      }
+    }
+    if (Date.now() - startedAt >= timeout) {
+      throw new WaitForTransactionTimeoutError(`Timed out after ${timeout}ms waiting for transaction ${txid}`, { txid });
+    }
+    await sleep2(pollingInterval);
+  }
+}
+
+// src/errors/websocket.ts
+class WebSocketError extends BaseError {
+  name = "WebSocketError";
+}
+
+// src/subscriptions/actions.ts
+function getWsTransport(client) {
+  if (client.transport.type !== "webSocket") {
+    throw new WebSocketError("Watch actions require a webSocket transport. Use `webSocket()` when creating your client.");
+  }
+  return client.transport;
+}
+async function watchBlocks(client, params) {
+  const transport = getWsTransport(client);
+  return transport.subscribe({ event: "block" }, params.onBlock);
+}
+async function watchMempool(client, params) {
+  const transport = getWsTransport(client);
+  return transport.subscribe({ event: "mempool" }, params.onTransaction);
+}
+async function watchTransaction(client, params) {
+  const transport = getWsTransport(client);
+  return transport.subscribe({ event: "tx_update", tx_id: params.txId }, params.onUpdate);
+}
+async function watchAddress(client, params) {
+  const transport = getWsTransport(client);
+  return transport.subscribe({ event: "address_tx_update", address: params.address }, params.onTransaction);
+}
+async function watchAddressBalance(client, params) {
+  const transport = getWsTransport(client);
+  return transport.subscribe({ event: "address_balance_update", address: params.address }, params.onBalance);
+}
+async function watchNftEvent(client, params) {
+  const transport = getWsTransport(client);
+  let event;
+  if (params.assetIdentifier && params.value) {
+    event = "nft_event";
+  } else if (params.assetIdentifier) {
+    event = "nft_collection_event";
+  } else {
+    event = "nft_event";
+  }
+  return transport.subscribe({
+    event,
+    asset_identifier: params.assetIdentifier,
+    value: params.value
+  }, params.onEvent);
+}
+
+// src/clients/decorators/public.ts
+function publicActions(client) {
+  return {
+    getNonce: (params) => getNonce(client, params),
+    getBalance: (params) => getBalance(client, params),
+    getAccountInfo: (params) => getAccountInfo(client, params),
+    getBlock: (params) => getBlock(client, params),
+    getRawBlock: (params) => getRawBlock(client, params),
+    getBlockHeight: () => getBlockHeight(client),
+    readContract: (params) => readContract(client, params),
+    getContractAbi: (params) => getContractAbi(client, params),
+    getContractSource: (params) => getContractSource(client, params),
+    getDataVar: (params) => getDataVar(client, params),
+    getMapEntry: (params) => getMapEntry(client, params),
+    estimateFee: (params) => estimateFee(client, params),
+    multicall: (params) => multicall(client, params),
+    simulateCall: (params) => simulateCall(client, params),
+    simulateTransaction: (params) => simulateTransaction(client, params),
+    getTransaction: (params) => getTransaction(client, params),
+    getAccountHistory: (params) => getAccountHistory(client, params),
+    getMempoolStats: () => getMempoolStats(client),
+    getNftHoldings: (params) => getNftHoldings(client, params),
+    waitForTransactionReceipt: (params) => waitForTransactionReceipt(client, params),
+    watchBlocks: (params) => watchBlocks(client, params),
+    watchMempool: (params) => watchMempool(client, params),
+    watchTransaction: (params) => watchTransaction(client, params),
+    watchAddress: (params) => watchAddress(client, params),
+    watchAddressBalance: (params) => watchAddressBalance(client, params),
+    watchNftEvent: (params) => watchNftEvent(client, params)
+  };
+}
+
+// src/clients/createPublicClient.ts
+function createPublicClient(config) {
+  return createClient(config).extend(publicActions);
+}
+// src/transactions/wire/deserialize.ts
+function readSpendingCondition(r) {
+  const hashMode = r.readUInt8();
+  const signer = bytesToHex(r.readBytes(20));
+  const nonce = r.readBigUInt64BE();
+  const fee = r.readBigUInt64BE();
+  if (hashMode === AddressHashMode.P2PKH || hashMode === AddressHashMode.P2WPKH) {
+    const keyEncoding = r.readUInt8();
+    const signature = bytesToHex(r.readBytes(RECOVERABLE_ECDSA_SIG_LENGTH_BYTES));
+    return {
+      hashMode,
+      signer,
+      nonce,
+      fee,
+      keyEncoding,
+      signature
+    };
+  }
+  const fieldCount = r.readUInt32BE();
+  const fields = [];
+  for (let i = 0;i < fieldCount; i++) {
+    const fieldType = r.readUInt8();
+    if (fieldType <= 1) {
+      const keyLen = fieldType === 0 ? 33 : 65;
+      fields.push({
+        type: "publicKey",
+        pubKeyEncoding: fieldType,
+        data: bytesToHex(r.readBytes(keyLen))
+      });
+    } else {
+      fields.push({
+        type: "signature",
+        pubKeyEncoding: fieldType === 2 ? 0 : 1,
+        data: bytesToHex(r.readBytes(RECOVERABLE_ECDSA_SIG_LENGTH_BYTES))
+      });
+    }
+  }
+  const signaturesRequired = r.readUInt16BE();
+  return {
+    hashMode,
+    signer,
+    nonce,
+    fee,
+    fields,
+    signaturesRequired
+  };
+}
+function readAuthorization(r) {
+  const authType = r.readUInt8();
+  const spendingCondition = readSpendingCondition(r);
+  if (authType === AuthType.Standard) {
+    return { authType: AuthType.Standard, spendingCondition };
+  }
+  const sponsorSpendingCondition = readSpendingCondition(r);
+  return {
+    authType: AuthType.Sponsored,
+    spendingCondition,
+    sponsorSpendingCondition
+  };
+}
+function readAssetInfo(r) {
+  return {
+    address: readAddress(r),
+    contractName: readLPString(r),
+    assetName: readLPString(r)
+  };
+}
+function readPostConditionPrincipal(r) {
+  const type = r.readUInt8();
+  switch (type) {
+    case PostConditionPrincipalId.Origin:
+      return { type: "origin" };
+    case PostConditionPrincipalId.Standard:
+      return { type: "standard", address: readAddress(r) };
+    case PostConditionPrincipalId.Contract:
+      return {
+        type: "contract",
+        address: readAddress(r),
+        contractName: readLPString(r)
+      };
+    default:
+      return { type: "origin" };
+  }
+}
+function readPostCondition(r) {
+  const assetType = r.readUInt8();
+  const principal = readPostConditionPrincipal(r);
+  switch (assetType) {
+    case AssetType.STX:
+      return {
+        type: "stx",
+        principal,
+        conditionCode: r.readUInt8(),
+        amount: r.readBigUInt64BE()
+      };
+    case AssetType.Fungible:
+      return {
+        type: "ft",
+        principal,
+        asset: readAssetInfo(r),
+        conditionCode: r.readUInt8(),
+        amount: r.readBigUInt64BE()
+      };
+    case AssetType.NonFungible:
+      return {
+        type: "nft",
+        principal,
+        asset: readAssetInfo(r),
+        assetId: readCV(r),
+        conditionCode: r.readUInt8()
+      };
+    case AssetType.Staking:
+      return {
+        type: "staking",
+        principal,
+        conditionCode: r.readUInt8(),
+        amount: r.readBigUInt64BE()
+      };
+    case AssetType.Pox:
+      return {
+        type: "pox",
+        principal,
+        conditionCode: r.readUInt8()
+      };
+    default:
+      throw new Error(`Unknown post-condition asset type: 0x${assetType.toString(16).padStart(2, "0")}`);
+  }
+}
+function readPostConditions(r) {
+  const count = r.readUInt32BE();
+  const pcs = [];
+  for (let i = 0;i < count; i++) {
+    try {
+      pcs.push(readPostCondition(r));
+    } catch (e) {
+      if (e instanceof Error && e.message.startsWith("Unknown post-condition asset type:")) {
+        throw new Error(`${e.message} (post-condition ${i + 1}/${count})`);
+      }
+      throw e;
+    }
+  }
+  return pcs;
+}
+function readPayload(r) {
+  const payloadType = r.readUInt8();
+  switch (payloadType) {
+    case PayloadType.TokenTransfer: {
+      const recipient = readCV(r);
+      const amount = r.readBigUInt64BE();
+      const memoBytes = r.readBytes(MEMO_MAX_LENGTH_BYTES);
+      const memo = bytesToAscii(memoBytes).replace(/\0+$/, "");
+      return {
+        payloadType: PayloadType.TokenTransfer,
+        recipient,
+        amount,
+        memo
+      };
+    }
+    case PayloadType.ContractCall: {
+      const contractAddress = readAddress(r);
+      const contractName = readLPString(r);
+      const functionName = readLPString(r);
+      const numArgs = r.readUInt32BE();
+      const functionArgs = [];
+      for (let i = 0;i < numArgs; i++)
+        functionArgs.push(readCV(r));
+      return {
+        payloadType: PayloadType.ContractCall,
+        contractAddress,
+        contractName,
+        functionName,
+        functionArgs
+      };
+    }
+    case PayloadType.SmartContract: {
+      const contractName = readLPString(r);
+      const codeBody = readLPString(r, 4);
+      return { payloadType: PayloadType.SmartContract, contractName, codeBody };
+    }
+    case PayloadType.VersionedSmartContract: {
+      const clarityVersion = r.readUInt8();
+      const contractName = readLPString(r);
+      const codeBody = readLPString(r, 4);
+      return {
+        payloadType: PayloadType.VersionedSmartContract,
+        clarityVersion,
+        contractName,
+        codeBody
+      };
+    }
+    case PayloadType.Coinbase: {
+      const coinbaseBuffer = bytesToHex(r.readBytes(COINBASE_BYTES_LENGTH));
+      return { payloadType: PayloadType.Coinbase, coinbaseBuffer };
+    }
+    case PayloadType.CoinbaseToAltRecipient: {
+      const coinbaseBuffer = bytesToHex(r.readBytes(COINBASE_BYTES_LENGTH));
+      const recipient = readCV(r);
+      return {
+        payloadType: PayloadType.CoinbaseToAltRecipient,
+        coinbaseBuffer,
+        recipient
+      };
+    }
+    case PayloadType.PoisonMicroblock: {
+      const header1 = bytesToHex(r.readBytes(MICROBLOCK_HEADER_BYTES_LENGTH));
+      const header2 = bytesToHex(r.readBytes(MICROBLOCK_HEADER_BYTES_LENGTH));
+      return { payloadType: PayloadType.PoisonMicroblock, header1, header2 };
+    }
+    case PayloadType.TenureChange: {
+      const tenureConsensusHash = bytesToHex(r.readBytes(20));
+      const prevTenureConsensusHash = bytesToHex(r.readBytes(20));
+      const burnViewConsensusHash = bytesToHex(r.readBytes(20));
+      const previousTenureEnd = bytesToHex(r.readBytes(32));
+      const previousTenureBlocks = r.readUInt32BE();
+      const cause = r.readUInt8();
+      const pubkeyHash = bytesToHex(r.readBytes(20));
+      return {
+        payloadType: PayloadType.TenureChange,
+        tenureConsensusHash,
+        prevTenureConsensusHash,
+        burnViewConsensusHash,
+        previousTenureEnd,
+        previousTenureBlocks,
+        cause,
+        pubkeyHash
+      };
+    }
+    case PayloadType.NakamotoCoinbase: {
+      const coinbaseBuffer = bytesToHex(r.readBytes(COINBASE_BYTES_LENGTH));
+      const optionalCV = readCV(r);
+      const recipient = optionalCV.type === "none" ? null : optionalCV.type === "some" ? optionalCV.value : optionalCV;
+      const vrfProof = bytesToHex(r.readBytes(VRF_PROOF_BYTES_LENGTH));
+      return {
+        payloadType: PayloadType.NakamotoCoinbase,
+        coinbaseBuffer,
+        recipient,
+        vrfProof
+      };
+    }
+    default:
+      throw new Error(`Unknown payload type: ${payloadType}`);
+  }
+}
+function deserializePostConditionWire(input) {
+  const bytes = typeof input === "string" ? hexToBytes(without0x(input)) : input;
+  return readPostCondition(new BytesReader(bytes));
+}
+function deserializeTransaction(input, meta) {
+  const bytes = typeof input === "string" ? hexToBytes(without0x(input)) : input;
+  const r = new BytesReader(bytes);
+  const tx = {
+    version: r.readUInt8(),
+    chainId: r.readUInt32BE(),
+    auth: readAuthorization(r),
+    anchorMode: r.readUInt8(),
+    postConditionMode: r.readUInt8(),
+    postConditions: readPostConditions(r),
+    payload: readPayload(r)
+  };
+  if (meta?._multisig) {
+    tx._multisig = meta._multisig;
+  }
+  return tx;
+}
+
+// src/postconditions/convert.ts
+var MAX_U64 = 18446744073709551615n;
+function parsePostConditionAmount(amount) {
+  const value = intToBigInt(amount);
+  if (value < 0n || value > MAX_U64) {
+    throw new RangeError(`Post-condition amount must be between 0 and ${MAX_U64} (u64 max), received: ${value}`);
+  }
+  return value;
+}
+var FUNGIBLE_CODE_MAP = {
+  eq: FungibleConditionCode.Equal,
+  gt: FungibleConditionCode.Greater,
+  gte: FungibleConditionCode.GreaterEqual,
+  lt: FungibleConditionCode.Less,
+  lte: FungibleConditionCode.LessEqual
+};
+var FUNGIBLE_CODE_REVERSE = {
+  [FungibleConditionCode.Equal]: "eq",
+  [FungibleConditionCode.Greater]: "gt",
+  [FungibleConditionCode.GreaterEqual]: "gte",
+  [FungibleConditionCode.Less]: "lt",
+  [FungibleConditionCode.LessEqual]: "lte"
+};
+var NFT_CODE_MAP = {
+  sent: NonFungibleConditionCode.Sends,
+  "not-sent": NonFungibleConditionCode.DoesNotSend,
+  "maybe-sent": NonFungibleConditionCode.MaybeSent
+};
+var NFT_CODE_REVERSE = {
+  [NonFungibleConditionCode.Sends]: "sent",
+  [NonFungibleConditionCode.DoesNotSend]: "not-sent",
+  [NonFungibleConditionCode.MaybeSent]: "maybe-sent"
+};
+var POX_CODE_MAP = {
+  "will-not-perform": PoxConditionCode.WillNotPerform,
+  "may-perform": PoxConditionCode.MayPerform,
+  "will-perform": PoxConditionCode.WillPerform
+};
+var POX_CODE_REVERSE = {
+  [PoxConditionCode.WillNotPerform]: "will-not-perform",
+  [PoxConditionCode.MayPerform]: "may-perform",
+  [PoxConditionCode.WillPerform]: "will-perform"
+};
+function resolvePrincipal(address) {
+  if (address === "origin")
+    return { type: "origin" };
+  const [addr, name] = address.split(".");
+  if (name) {
+    return { type: "contract", address: addr, contractName: name };
+  }
+  return { type: "standard", address: addr };
+}
+function principalToString(principal) {
+  if (principal.type === "origin")
+    return "origin";
+  if (principal.type === "contract") {
+    return `${principal.address}.${principal.contractName}`;
+  }
+  return principal.address;
+}
+function assetToString(asset) {
+  return `${asset.address}.${asset.contractName}::${asset.assetName}`;
+}
+function parseAsset(asset) {
+  const [contractId, tokenName] = asset.split("::");
+  const [addr, name] = parseContractId(contractId);
+  return { address: addr, contractName: name, assetName: tokenName };
+}
+function convertPostCondition(pc) {
+  switch (pc.type) {
+    case "stx-postcondition":
+      return {
+        type: "stx",
+        principal: resolvePrincipal(pc.address),
+        conditionCode: FUNGIBLE_CODE_MAP[pc.condition],
+        amount: parsePostConditionAmount(pc.amount)
+      };
+    case "ft-postcondition":
+      return {
+        type: "ft",
+        principal: resolvePrincipal(pc.address),
+        asset: parseAsset(pc.asset),
+        conditionCode: FUNGIBLE_CODE_MAP[pc.condition],
+        amount: parsePostConditionAmount(pc.amount)
+      };
+    case "nft-postcondition":
+      return {
+        type: "nft",
+        principal: resolvePrincipal(pc.address),
+        asset: parseAsset(pc.asset),
+        conditionCode: NFT_CODE_MAP[pc.condition],
+        assetId: pc.assetId
+      };
+    case "staking-postcondition":
+      return {
+        type: "staking",
+        principal: resolvePrincipal(pc.address),
+        conditionCode: FUNGIBLE_CODE_MAP[pc.condition],
+        amount: parsePostConditionAmount(pc.amount)
+      };
+    case "pox-postcondition":
+      return {
+        type: "pox",
+        principal: resolvePrincipal(pc.address),
+        conditionCode: POX_CODE_MAP[pc.condition]
+      };
+  }
+}
+function wireToPostCondition(wire) {
+  switch (wire.type) {
+    case "stx":
+      return {
+        type: "stx-postcondition",
+        address: principalToString(wire.principal),
+        condition: fungibleName(wire.conditionCode),
+        amount: wire.amount.toString()
+      };
+    case "ft":
+      return {
+        type: "ft-postcondition",
+        address: principalToString(wire.principal),
+        condition: fungibleName(wire.conditionCode),
+        amount: wire.amount.toString(),
+        asset: assetToString(wire.asset)
+      };
+    case "nft":
+      return {
+        type: "nft-postcondition",
+        address: principalToString(wire.principal),
+        condition: nftName(wire.conditionCode),
+        asset: assetToString(wire.asset),
+        assetId: wire.assetId
+      };
+    case "staking":
+      return {
+        type: "staking-postcondition",
+        address: principalToString(wire.principal),
+        condition: fungibleName(wire.conditionCode),
+        amount: wire.amount.toString()
+      };
+    case "pox":
+      return {
+        type: "pox-postcondition",
+        address: principalToString(wire.principal),
+        condition: poxName(wire.conditionCode)
+      };
+  }
+}
+function fungibleName(code) {
+  const name = FUNGIBLE_CODE_REVERSE[code];
+  if (!name)
+    throw new Error(`Unknown fungible post-condition code: ${code}`);
+  return name;
+}
+function nftName(code) {
+  const name = NFT_CODE_REVERSE[code];
+  if (!name)
+    throw new Error(`Unknown nft post-condition code: ${code}`);
+  return name;
+}
+function poxName(code) {
+  const name = POX_CODE_REVERSE[code];
+  if (!name)
+    throw new Error(`Unknown pox post-condition code: ${code}`);
+  return name;
+}
+function fromHex(hex) {
+  return wireToPostCondition(deserializePostConditionWire(hex));
+}
+function postConditionToHex(pc) {
+  return bytesToHex(serializePostConditionWire(convertPostCondition(pc)));
+}
+
+// src/transactions/authorization.ts
+var import_hmac = require("@noble/hashes/hmac.js");
+var import_sha24 = require("@noble/hashes/sha2.js");
+var import_secp256k1 = require("@noble/secp256k1");
+import_secp256k1.etc.hmacSha256Sync = (key, ...msgs) => {
+  const h = import_hmac.hmac.create(import_sha24.sha256, key);
+  for (const msg of msgs)
+    h.update(msg);
+  return h.digest();
+};
+var EMPTY_SIG = bytesToHex(new Uint8Array(RECOVERABLE_ECDSA_SIG_LENGTH_BYTES));
+function createSingleSigSpendingCondition(publicKey, nonce, fee) {
+  const pubKeyBytes = hexToBytes(publicKey);
+  const signer = hashP2PKH(pubKeyBytes);
+  const isCompressed = pubKeyBytes.length === 33;
+  return {
+    hashMode: AddressHashMode.P2PKH,
+    signer,
+    nonce,
+    fee,
+    keyEncoding: isCompressed ? PubKeyEncoding.Compressed : PubKeyEncoding.Uncompressed,
+    signature: EMPTY_SIG
+  };
+}
+function createStandardAuth(spendingCondition) {
+  return { authType: AuthType.Standard, spendingCondition };
+}
+function createSponsoredAuth(spendingCondition, sponsorSpendingCondition) {
+  return {
+    authType: AuthType.Sponsored,
+    spendingCondition,
+    sponsorSpendingCondition: sponsorSpendingCondition ?? createSingleSigSpendingCondition("0".repeat(66), 0n, 0n)
+  };
+}
+function clearCondition(condition) {
+  if ("signature" in condition) {
+    return {
+      ...condition,
+      nonce: 0n,
+      fee: 0n,
+      signature: EMPTY_SIG
+    };
+  }
+  return {
+    ...condition,
+    nonce: 0n,
+    fee: 0n,
+    fields: []
+  };
+}
+function sponsorSigningSentinel() {
+  return {
+    hashMode: AddressHashMode.P2PKH,
+    signer: "00".repeat(20),
+    nonce: 0n,
+    fee: 0n,
+    keyEncoding: PubKeyEncoding.Compressed,
+    signature: EMPTY_SIG
+  };
+}
+function intoInitialSighashAuth(auth) {
+  if (auth.authType === AuthType.Standard) {
+    return createStandardAuth(clearCondition(auth.spendingCondition));
+  }
+  return createSponsoredAuth(clearCondition(auth.spendingCondition), sponsorSigningSentinel());
+}
+function sigHashPreSign(curSigHash, authType, fee, nonce) {
+  const data = concatBytes(hexToBytes(curSigHash), new Uint8Array([authType]), intToBytes(fee, 8), intToBytes(nonce, 8));
+  return txidFromBytes(data);
+}
+function sigHashPostSign(curSigHash, pubKeyEncoding, signature) {
+  const data = concatBytes(hexToBytes(curSigHash), new Uint8Array([pubKeyEncoding]), hexToBytes(signature));
+  return txidFromBytes(data);
+}
+function signWithKey(privateKey, messageHash) {
+  const keyBytes = hexToBytes(privateKey).slice(0, 32);
+  const sig = import_secp256k1.sign(messageHash, keyBytes, { lowS: true });
+  const recoveryIdHex = intToHex(sig.recovery, 1);
+  return recoveryIdHex + sig.toCompactHex();
+}
+function nextSignature(curSigHash, authType, fee, nonce, privateKey) {
+  const sigHashPre = sigHashPreSign(curSigHash, authType, fee, nonce);
+  const keyBytes = hexToBytes(privateKey).slice(0, 32);
+  const pubKey = import_secp256k1.getPublicKey(keyBytes, true);
+  const isCompressed = pubKey.length === 33;
+  const pubKeyEncoding = isCompressed ? PubKeyEncoding.Compressed : PubKeyEncoding.Uncompressed;
+  const nextSig = signWithKey(privateKey, sigHashPre);
+  const nextSigHash = sigHashPostSign(sigHashPre, pubKeyEncoding, nextSig);
+  return { nextSig, nextSigHash };
+}
+
+// src/transactions/multisig.ts
+var import_secp256k12 = require("@noble/secp256k1");
+var OP_CHECKMULTISIG = 174;
+function isNonSequential(hashMode) {
+  return (hashMode & 4) !== 0;
+}
+function makeRedeemScript(publicKeys, signaturesRequired) {
+  const parts = [];
+  parts.push(new Uint8Array([80 + signaturesRequired]));
+  for (const pk of publicKeys) {
+    const pkBytes = hexToBytes(pk);
+    parts.push(new Uint8Array([pkBytes.length]));
+    parts.push(pkBytes);
+  }
+  parts.push(new Uint8Array([80 + publicKeys.length]));
+  parts.push(new Uint8Array([OP_CHECKMULTISIG]));
+  return concatBytes(...parts);
+}
+function makeMultiSigAddress(publicKeys, signaturesRequired, chain) {
+  if (signaturesRequired < 1 || signaturesRequired > publicKeys.length) {
+    throw new Error(`signaturesRequired must be between 1 and ${publicKeys.length}`);
+  }
+  const redeemScript = makeRedeemScript(publicKeys, signaturesRequired);
+  const signer = hash160(redeemScript);
+  const version = chain?.addressVersion?.multiSig ?? 20;
+  return c32address(version, bytesToHex(signer));
+}
+function createMultiSigSpendingCondition(publicKeys, signaturesRequired, nonce, fee, hashMode = AddressHashMode.P2SH) {
+  const redeemScript = makeRedeemScript(publicKeys, signaturesRequired);
+  const signer = bytesToHex(hash160(redeemScript));
+  return {
+    hashMode,
+    signer,
+    nonce,
+    fee,
+    fields: [],
+    signaturesRequired
+  };
+}
+function initialSigHash(tx) {
+  const cleared = {
+    ...tx,
+    auth: intoInitialSighashAuth(tx.auth)
+  };
+  return txidFromBytes(serializeTransaction(cleared));
+}
+function nonSequentialPreSignHash(tx) {
+  const condition = tx.auth.spendingCondition;
+  const initHash = initialSigHash(tx);
+  return sigHashPreSign(initHash, AuthType.Standard, condition.fee, condition.nonce);
+}
+function replayMultiSigSigHash(tx) {
+  const condition = tx.auth.spendingCondition;
+  if (isNonSequential(condition.hashMode)) {
+    const preSign = nonSequentialPreSignHash(tx);
+    let curSigHash2 = preSign;
+    for (const field of condition.fields) {
+      curSigHash2 = sigHashPostSign(curSigHash2, field.pubKeyEncoding, field.data);
+    }
+    return curSigHash2;
+  }
+  let curSigHash = initialSigHash(tx);
+  for (const field of condition.fields) {
+    const preSign = sigHashPreSign(curSigHash, AuthType.Standard, condition.fee, condition.nonce);
+    curSigHash = sigHashPostSign(preSign, field.pubKeyEncoding, field.data);
+  }
+  return curSigHash;
+}
+function signMultiSig(tx, privateKey, publicKeys) {
+  const keyBytes = hexToBytes(privateKey).slice(0, 32);
+  const signerPubKey = bytesToHex(import_secp256k12.getPublicKey(keyBytes, true));
+  const signerIndex = publicKeys.findIndex((pk) => pk === signerPubKey);
+  if (signerIndex === -1) {
+    throw new Error("Private key does not correspond to any signer in the multi-sig");
+  }
+  const condition = {
+    ...tx.auth.spendingCondition
+  };
+  if (isNonSequential(condition.hashMode)) {
+    return signNonSequential(tx, condition, privateKey);
+  }
+  return signSequential(tx, condition, privateKey, publicKeys, signerIndex);
+}
+function signNonSequential(tx, condition, privateKey) {
+  const fields = [...condition.fields];
+  const preSignHash = nonSequentialPreSignHash(tx);
+  const keyBytes = hexToBytes(privateKey).slice(0, 32);
+  const sig = import_secp256k12.sign(preSignHash, keyBytes, { lowS: true });
+  const recoveryIdHex = intToHex(sig.recovery, 1);
+  const nextSig = recoveryIdHex + sig.toCompactHex();
+  fields.push({
+    type: "signature",
+    pubKeyEncoding: PubKeyEncoding.Compressed,
+    data: nextSig
+  });
+  const newCondition = { ...condition, fields };
+  const sigCount = fields.filter((f) => f.type === "signature").length;
+  if (sigCount >= condition.signaturesRequired) {
+    return {
+      ...tx,
+      auth: { ...tx.auth, spendingCondition: newCondition }
+    };
+  }
+  return {
+    ...tx,
+    auth: { ...tx.auth, spendingCondition: newCondition }
+  };
+}
+function signSequential(tx, condition, privateKey, publicKeys, signerIndex) {
+  const fields = [...condition.fields];
+  let curSigHash = initialSigHash(tx);
+  for (const field of fields) {
+    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 = {
+      type: "publicKey",
+      pubKeyEncoding: PubKeyEncoding.Compressed,
+      data: publicKeys[i]
+    };
+    fields.push(pubKeyField);
+    const preSign = sigHashPreSign(curSigHash, AuthType.Standard, condition.fee, condition.nonce);
+    curSigHash = sigHashPostSign(preSign, pubKeyField.pubKeyEncoding, pubKeyField.data);
+  }
+  const { nextSig, nextSigHash } = nextSignature(curSigHash, AuthType.Standard, condition.fee, condition.nonce, privateKey);
+  fields.push({
+    type: "signature",
+    pubKeyEncoding: PubKeyEncoding.Compressed,
+    data: nextSig
+  });
+  curSigHash = nextSigHash;
+  const newCondition = { ...condition, fields };
+  const sigCount = fields.filter((f) => f.type === "signature").length;
+  let finalCondition = newCondition;
+  if (sigCount >= condition.signaturesRequired) {
+    finalCondition = finalizeMultiSigCondition(newCondition, publicKeys, curSigHash);
+  }
+  return {
+    ...tx,
+    auth: {
+      ...tx.auth,
+      spendingCondition: finalCondition
+    }
+  };
+}
+async function signMultiSigWithAccount(tx, account, publicKeys) {
+  const signerPubKey = account.publicKey;
+  const signerIndex = publicKeys.findIndex((pk) => pk === signerPubKey);
+  if (signerIndex === -1) {
+    throw new Error("Account does not correspond to any signer in the multi-sig");
+  }
+  const condition = {
+    ...tx.auth.spendingCondition
+  };
+  if (isNonSequential(condition.hashMode)) {
+    return signNonSequentialWithAccount(tx, condition, account);
+  }
+  return signSequentialWithAccount(tx, condition, account, publicKeys, signerIndex);
+}
+async function signNonSequentialWithAccount(tx, condition, account) {
+  const fields = [...condition.fields];
+  const preSignHash = nonSequentialPreSignHash(tx);
+  const sigBytes = await account.sign(hexToBytes(preSignHash));
+  const nextSig = bytesToHex(sigBytes);
+  fields.push({
+    type: "signature",
+    pubKeyEncoding: PubKeyEncoding.Compressed,
+    data: nextSig
+  });
+  const newCondition = { ...condition, fields };
+  return {
+    ...tx,
+    auth: { ...tx.auth, spendingCondition: newCondition }
+  };
+}
+async function signSequentialWithAccount(tx, condition, account, publicKeys, signerIndex) {
+  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);
+  }
+  for (let i = fields.length;i < signerIndex; i++) {
+    const pubKeyField = {
+      type: "publicKey",
+      pubKeyEncoding: PubKeyEncoding.Compressed,
+      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);
+  const sigBytes = await account.sign(hexToBytes(preSign));
+  const nextSig = bytesToHex(sigBytes);
+  const nextSigHash = sigHashPostSign(preSign, PubKeyEncoding.Compressed, nextSig);
+  fields.push({
+    type: "signature",
+    pubKeyEncoding: PubKeyEncoding.Compressed,
+    data: nextSig
+  });
+  curSigHash = nextSigHash;
+  const newCondition = { ...condition, fields };
+  const sigCount = fields.filter((f) => f.type === "signature").length;
+  let finalCondition = newCondition;
+  if (sigCount >= condition.signaturesRequired) {
+    finalCondition = finalizeMultiSigCondition(newCondition, publicKeys, curSigHash);
+  }
+  return {
+    ...tx,
+    auth: {
+      ...tx.auth,
+      spendingCondition: finalCondition
+    }
+  };
+}
+function finalizeMultiSig(tx, publicKeys) {
+  const condition = tx.auth.spendingCondition;
+  if (isNonSequential(condition.hashMode)) {
+    return tx;
+  }
+  const curSigHash = replayMultiSigSigHash(tx);
+  const finalCondition = finalizeMultiSigCondition(condition, publicKeys, curSigHash);
+  return {
+    ...tx,
+    auth: {
+      ...tx.auth,
+      spendingCondition: finalCondition
+    }
+  };
+}
+function finalizeMultiSigCondition(condition, publicKeys, curSigHash) {
+  const fields = [...condition.fields];
+  let sigHash = curSigHash;
+  for (let i = fields.length;i < publicKeys.length; i++) {
+    const pubKeyField = {
+      type: "publicKey",
+      pubKeyEncoding: PubKeyEncoding.Compressed,
+      data: publicKeys[i]
+    };
+    fields.push(pubKeyField);
+    const preSign = sigHashPreSign(sigHash, AuthType.Standard, condition.fee, condition.nonce);
+    sigHash = sigHashPostSign(preSign, pubKeyField.pubKeyEncoding, pubKeyField.data);
+  }
+  return { ...condition, fields };
+}
+function combineMultiSigSignatures(baseTx, signedTxs) {
+  const condition = baseTx.auth.spendingCondition;
+  if (!isNonSequential(condition.hashMode)) {
+    throw new Error("combineMultiSigSignatures only works with non-sequential hash modes (SIP-027)");
+  }
+  const seenSigs = new Set;
+  const signatures = [];
+  for (const stx of signedTxs) {
+    const stxCondition = stx.auth.spendingCondition;
+    for (const field of stxCondition.fields) {
+      if (field.type === "signature" && !seenSigs.has(field.data)) {
+        seenSigs.add(field.data);
+        signatures.push(field);
+      }
+    }
+  }
+  if (signatures.length === 0) {
+    throw new Error("No signatures found in the provided transactions");
+  }
+  const newCondition = {
+    ...condition,
+    fields: signatures
+  };
+  return {
+    ...baseTx,
+    auth: { ...baseTx.auth, spendingCondition: newCondition }
+  };
+}
+
+// src/transactions/build.ts
+function resolvePcMode(mode) {
+  if (mode === "allow")
+    return PostConditionModeWire.Allow;
+  if (mode === "originator")
+    return PostConditionModeWire.Originator;
+  return PostConditionModeWire.Deny;
+}
+function convertPostConditions(pcs) {
+  if (!pcs || pcs.length === 0)
+    return [];
+  return pcs.map((pc) => convertPostCondition(typeof pc === "string" ? fromHex(pc) : pc));
+}
+function resolveSpendingCondition(opts, nonce, fee) {
+  if (opts.publicKeys) {
+    return createMultiSigSpendingCondition(opts.publicKeys, opts.signaturesRequired, nonce, fee, opts.hashMode);
+  }
+  return createSingleSigSpendingCondition(opts.publicKey, nonce, fee);
+}
+function resolveAuth(spendingCondition, sponsored) {
+  return sponsored ? createSponsoredAuth(spendingCondition) : createStandardAuth(spendingCondition);
+}
+function resolveVersionAndChainId(chain) {
+  if (!chain)
+    return { version: 0, chainId: 1 };
+  return { version: chain.transactionVersion, chainId: chain.id };
+}
+function buildTokenTransfer(options) {
+  const { version, chainId } = resolveVersionAndChainId(options.chain);
+  const fee = intToBigInt(options.fee);
+  const nonce = intToBigInt(options.nonce);
+  const spendingCondition = resolveSpendingCondition(options, nonce, fee);
+  const recipient = Cl.principal(options.recipient);
+  const tx = {
+    version,
+    chainId,
+    auth: resolveAuth(spendingCondition, options.sponsored),
+    anchorMode: AnchorMode.Any,
+    postConditionMode: resolvePcMode(options.postConditionMode),
+    postConditions: convertPostConditions(options.postConditions),
+    payload: {
+      payloadType: PayloadType.TokenTransfer,
+      recipient,
+      amount: intToBigInt(options.amount),
+      memo: options.memo ?? ""
     }
-    next.extend = bindExtend(next);
-    return next;
   };
+  if (options.publicKeys) {
+    tx._multisig = { publicKeys: options.publicKeys };
+  }
+  return tx;
 }
-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
+function buildContractCall(options) {
+  const { version, chainId } = resolveVersionAndChainId(options.chain);
+  const fee = intToBigInt(options.fee);
+  const nonce = intToBigInt(options.nonce);
+  const spendingCondition = resolveSpendingCondition(options, nonce, fee);
+  const tx = {
+    version,
+    chainId,
+    auth: resolveAuth(spendingCondition, options.sponsored),
+    anchorMode: AnchorMode.Any,
+    postConditionMode: resolvePcMode(options.postConditionMode),
+    postConditions: convertPostConditions(options.postConditions),
+    payload: {
+      payloadType: PayloadType.ContractCall,
+      contractAddress: options.contractAddress,
+      contractName: options.contractName,
+      functionName: options.functionName,
+      functionArgs: options.functionArgs
+    }
   };
-  client.extend = bindExtend(client);
-  return client;
+  if (options.publicKeys) {
+    tx._multisig = { publicKeys: options.publicKeys };
+  }
+  return tx;
 }
-// src/clients/decorators/public.ts
-function publicActions(client) {
+function buildContractDeploy(options) {
+  const { version, chainId } = resolveVersionAndChainId(options.chain);
+  const fee = intToBigInt(options.fee);
+  const nonce = intToBigInt(options.nonce);
+  const spendingCondition = resolveSpendingCondition(options, nonce, fee);
+  const clarityVersion = options.clarityVersion ?? ClarityVersion.Clarity4;
+  const tx = {
+    version,
+    chainId,
+    auth: resolveAuth(spendingCondition, options.sponsored),
+    anchorMode: AnchorMode.Any,
+    postConditionMode: resolvePcMode(options.postConditionMode),
+    postConditions: convertPostConditions(options.postConditions),
+    payload: {
+      payloadType: PayloadType.VersionedSmartContract,
+      clarityVersion,
+      contractName: options.contractName,
+      codeBody: options.codeBody
+    }
+  };
+  if (options.publicKeys) {
+    tx._multisig = { publicKeys: options.publicKeys };
+  }
+  return tx;
+}
+
+// src/transactions/signer.ts
+function txid(tx) {
+  return txidFromBytes(serializeTransaction(tx));
+}
+function signBegin(tx) {
+  const cleared = {
+    ...tx,
+    auth: intoInitialSighashAuth(tx.auth)
+  };
+  return txid(cleared);
+}
+function signTransaction(tx, privateKey) {
+  const sigHash = signBegin(tx);
+  const condition = tx.auth.spendingCondition;
+  const { nextSig } = nextSignature(sigHash, AuthType.Standard, condition.fee, condition.nonce, privateKey);
   return {
-    getNonce: (params) => getNonce(client, params),
-    getBalance: (params) => getBalance(client, params),
-    getAccountInfo: (params) => getAccountInfo(client, params),
-    getBlock: (params) => getBlock(client, params),
-    getRawBlock: (params) => getRawBlock(client, params),
-    getBlockHeight: () => getBlockHeight(client),
-    readContract: (params) => readContract(client, params),
-    getContractAbi: (params) => getContractAbi(client, params),
-    getContractSource: (params) => getContractSource(client, params),
-    getDataVar: (params) => getDataVar(client, params),
-    getMapEntry: (params) => getMapEntry(client, params),
-    estimateFee: (params) => estimateFee(client, params),
-    multicall: (params) => multicall(client, params),
-    simulateCall: (params) => simulateCall(client, params),
-    simulateTransaction: (params) => simulateTransaction(client, params),
-    getTransaction: (params) => getTransaction(client, params),
-    getAccountHistory: (params) => getAccountHistory(client, params),
-    getMempoolStats: () => getMempoolStats(client),
-    getNftHoldings: (params) => getNftHoldings(client, params),
-    waitForTransactionReceipt: (params) => waitForTransactionReceipt(client, params),
-    watchBlocks: (params) => watchBlocks(client, params),
-    watchMempool: (params) => watchMempool(client, params),
-    watchTransaction: (params) => watchTransaction(client, params),
-    watchAddress: (params) => watchAddress(client, params),
-    watchAddressBalance: (params) => watchAddressBalance(client, params),
-    watchNftEvent: (params) => watchNftEvent(client, params)
+    ...tx,
+    auth: {
+      ...tx.auth,
+      spendingCondition: {
+        ...condition,
+        signature: nextSig
+      }
+    }
+  };
+}
+async function signTransactionWithAccount(tx, account) {
+  const sigHash = signBegin(tx);
+  const condition = tx.auth.spendingCondition;
+  const sigHashPre = sigHashPreSign(sigHash, AuthType.Standard, condition.fee, condition.nonce);
+  const sigBytes = await account.sign(hexToBytes(sigHashPre));
+  const nextSig = bytesToHex(sigBytes);
+  return {
+    ...tx,
+    auth: {
+      ...tx.auth,
+      spendingCondition: {
+        ...condition,
+        signature: nextSig
+      }
+    }
+  };
+}
+function getTransactionId(tx) {
+  return txid(tx);
+}
+function getOriginSigHash(tx) {
+  const condition = tx.auth.spendingCondition;
+  if ("fields" in condition) {
+    return replayMultiSigSigHash(tx);
+  }
+  const initialSigHash2 = signBegin(tx);
+  const sc = condition;
+  const preSign = sigHashPreSign(initialSigHash2, AuthType.Standard, sc.fee, sc.nonce);
+  return sigHashPostSign(preSign, sc.keyEncoding, sc.signature);
+}
+function signSponsor(tx, privateKey) {
+  if (tx.auth.authType !== AuthType.Sponsored) {
+    throw new Error("Transaction must be sponsored");
+  }
+  const auth = tx.auth;
+  const sponsorCondition = auth.sponsorSpendingCondition;
+  const originSigHash = getOriginSigHash(tx);
+  const { nextSig } = nextSignature(originSigHash, AuthType.Sponsored, sponsorCondition.fee, sponsorCondition.nonce, privateKey);
+  return {
+    ...tx,
+    auth: {
+      ...auth,
+      sponsorSpendingCondition: {
+        ...sponsorCondition,
+        signature: nextSig
+      }
+    }
+  };
+}
+async function signSponsorWithAccount(tx, account) {
+  if (tx.auth.authType !== AuthType.Sponsored) {
+    throw new Error("Transaction must be sponsored");
+  }
+  const auth = tx.auth;
+  const sponsorCondition = auth.sponsorSpendingCondition;
+  const originSigHash = getOriginSigHash(tx);
+  const sigHashPre = sigHashPreSign(originSigHash, AuthType.Sponsored, sponsorCondition.fee, sponsorCondition.nonce);
+  const sigBytes = await account.sign(hexToBytes(sigHashPre));
+  const nextSig = bytesToHex(sigBytes);
+  return {
+    ...tx,
+    auth: {
+      ...auth,
+      sponsorSpendingCondition: {
+        ...sponsorCondition,
+        signature: nextSig
+      }
+    }
   };
 }
 
-// src/clients/createPublicClient.ts
-function createPublicClient(config) {
-  return createClient(config).extend(publicActions);
+// src/actions/wallet/sendTransaction.ts
+async function sendTransaction(client, params) {
+  const hex = bytesToHex(serializeTransaction(params.transaction));
+  const body = { tx: hex };
+  if (params.attachment) {
+    body.attachment = typeof params.attachment === "string" ? params.attachment : bytesToHex(params.attachment);
+  }
+  let data;
+  try {
+    data = await client.request("/v2/transactions", {
+      method: "POST",
+      body,
+      retryCount: 0
+    });
+  } catch (error) {
+    if (error instanceof HttpRequestError && error.details) {
+      try {
+        data = JSON.parse(error.details);
+      } catch {
+        throw error;
+      }
+    } else if (error instanceof TimeoutError) {
+      const txid3 = getTransactionId(params.transaction);
+      const receipt = await getTransaction(client, { txid: txid3 }).catch(() => null);
+      if (receipt === null)
+        throw error;
+      data = { txid: txid3 };
+    } else {
+      throw error;
+    }
+  }
+  if (data.error) {
+    throw new BroadcastError(data.reason ?? data.error, {
+      reason: data.reason,
+      reasonData: data.reason_data,
+      txid: data.txid ?? getTransactionId(params.transaction)
+    });
+  }
+  const txid2 = 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,
+      confirmations
+    });
+    return { txid: txid2, receipt };
+  }
+  return { txid: txid2 };
+}
+
+// src/actions/wallet/nonceManager.ts
+function jsonRpcSource() {
+  return {
+    get: ({ client, address }) => getNonce(client, { address })
+  };
+}
+function memoryStore() {
+  const next = new Map;
+  const locks = new Map;
+  function withLock(key, fn) {
+    const prev = locks.get(key) ?? Promise.resolve();
+    const run = prev.then(fn, fn);
+    locks.set(key, run.catch(() => {}));
+    return run;
+  }
+  return {
+    reserve(key, getFloor) {
+      return withLock(key, async () => {
+        let current = next.get(key);
+        if (current === undefined)
+          current = await getFloor();
+        next.set(key, current + 1n);
+        return current;
+      });
+    },
+    reset(key) {
+      next.delete(key);
+    },
+    release(key, nonce) {
+      return withLock(key, async () => {
+        if (next.get(key) === nonce + 1n)
+          next.set(key, nonce);
+      });
+    },
+    peek(key) {
+      return next.get(key);
+    }
+  };
+}
+function nonceKey(client, address) {
+  return `${client.chain?.id ?? "stacks"}:${address}`;
+}
+function createNonceManager(params = {}) {
+  const source = params.source ?? jsonRpcSource();
+  const store = params.store ?? memoryStore();
+  return {
+    consume({ client, address }) {
+      return store.reserve(nonceKey(client, address), () => source.get({ client, address }));
+    },
+    reset({ client, address }) {
+      return store.reset(nonceKey(client, address));
+    },
+    release({ client, address, nonce }) {
+      return store.release?.(nonceKey(client, address), nonce);
+    },
+    async peek({ client, address }) {
+      return store.peek?.(nonceKey(client, address));
+    }
+  };
+}
+async function resolveNonce(client, address) {
+  if (client.nonceManager)
+    return client.nonceManager.consume({ client, address });
+  return getNonce(client, { address });
+}
+async function releaseNonce(client, address, nonce) {
+  if (!client.nonceManager)
+    return;
+  try {
+    await client.nonceManager.release({ client, address, nonce });
+  } catch {}
+}
+async function reconcileNonce(manager, params) {
+  const { client, address, source } = params;
+  const downward = params.downward ?? true;
+  const authoritative = await source.get({ client, address });
+  const tracked = await manager.peek({ client, address });
+  if (tracked === undefined || authoritative === tracked) {
+    return { reset: false, authoritative, tracked };
+  }
+  if (authoritative < tracked && !downward) {
+    return { reset: false, authoritative, tracked };
+  }
+  await manager.reset({ client, address });
+  return { reset: true, authoritative, tracked };
+}
+function startNonceReconciler(manager, params) {
+  const { client, addresses, source, clock } = params;
+  const intervalMs = params.intervalMs ?? 60000;
+  let running = true;
+  const tick = async () => {
+    if (!running)
+      return;
+    for (const address of addresses) {
+      try {
+        const result = await reconcileNonce(manager, {
+          client,
+          address,
+          source,
+          downward: params.downward
+        });
+        params.onReconcile?.(address, result);
+      } catch (error) {
+        try {
+          params.onError?.(address, error);
+        } catch {}
+      }
+    }
+    if (running && clock) {
+      await clock.advance(intervalMs);
+      tick();
+    }
+  };
+  if (clock) {
+    tick();
+    return {
+      stop: () => {
+        running = false;
+      }
+    };
+  }
+  const timer = setInterval(tick, intervalMs);
+  timer.unref?.();
+  return {
+    stop: () => clearInterval(timer)
+  };
+}
+function isNonceConflictError(error) {
+  if (!(error instanceof BroadcastError))
+    return false;
+  if (error.reason === "ConflictingNonceInMempool" || error.reason === "BadNonce") {
+    return true;
+  }
+  if (error.reason !== undefined)
+    return false;
+  return error.message.toLowerCase().includes("nonce");
+}
+async function broadcastWithNonceReset(client, params) {
+  try {
+    const result = await sendTransaction(client, {
+      transaction: params.transaction
+    });
+    return result.txid;
+  } catch (error) {
+    if (client.nonceManager && isNonceConflictError(error)) {
+      await client.nonceManager.reset({ client, address: params.address });
+    }
+    throw error;
+  }
+}
+
+// src/actions/wallet/utils.ts
+function isProviderAccount(account) {
+  return account.type === "provider";
+}
+var FEE_TIERS = ["min", "low", "mid", "high"];
+var TIER_INDEX = { low: 0, mid: 1, high: 2 };
+function isFeeTier(fee) {
+  return typeof fee === "string" && FEE_TIERS.includes(fee);
+}
+function minimumFee(transaction) {
+  return BigInt(serializeTransaction(transaction).length);
+}
+function isNoEstimateAvailable(error) {
+  return error instanceof HttpRequestError && error.status === 400 && (error.details?.includes("NoEstimateAvailable") ?? false);
+}
+async function resolveFee(client, transaction, fee) {
+  if (fee !== undefined && !isFeeTier(fee))
+    return { fee: intToBigInt(fee) };
+  const tier = fee ?? "mid";
+  if (tier === "min")
+    return { fee: minimumFee(transaction), tier };
+  let estimates;
+  try {
+    estimates = await estimateFee(client, { transaction });
+  } catch (error) {
+    if (!isNoEstimateAvailable(error))
+      throw error;
+    return { fee: minimumFee(transaction), tier: "min" };
+  }
+  const pick = estimates[TIER_INDEX[tier]] ?? estimates[estimates.length - 1];
+  if (pick)
+    return { fee: BigInt(pick.fee), tier };
+  return { fee: minimumFee(transaction), tier: "min" };
+}
+function setUnsignedFee(transaction, fee) {
+  transaction.auth.spendingCondition.fee = fee;
+  clearTxCache(transaction);
+}
+function assertNoFeeTierForProvider(fee) {
+  if (isFeeTier(fee)) {
+    throw new Error(`Fee tier '${fee}' requires local signing; provider (wallet) accounts set their own fee`);
+  }
+}
+
+// src/actions/wallet/callContract.ts
+async function callContract(client, params) {
+  const account = client.account;
+  if (!account)
+    throw new Error("Account required");
+  const [contractAddress, contractName] = parseContractId(params.contract);
+  if (isProviderAccount(account)) {
+    assertNoFeeTierForProvider(params.fee);
+    const result = await account.provider.request("stx_callContract", {
+      contract: params.contract,
+      functionName: params.functionName,
+      functionArgs: params.functionArgs ?? []
+    });
+    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 = buildContractCall({
+      contractAddress,
+      contractName,
+      functionName: params.functionName,
+      functionArgs: params.functionArgs ?? [],
+      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/deployContract.ts
+async function deployContract(client, params) {
+  const account = client.account;
+  if (!account)
+    throw new Error("Account required");
+  if (!isClarityName(params.contractName))
+    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
+    });
+    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;
+  }
+  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);
+    }
+    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/clients/decorators/wallet.ts
 function walletActions(client) {
   return {
@@ -714,6 +4461,132 @@ function webSocket(url, config) {
     return transport;
   };
 }
+// src/accounts/providerToAccount.ts
+async function providerToAccount(provider) {
+  const result = await provider.request("stx_getAddresses");
+  const entry = result?.addresses?.[0];
+  if (!entry?.address || !entry?.publicKey) {
+    throw new Error("Provider did not return a valid address");
+  }
+  return {
+    type: "provider",
+    address: entry.address,
+    publicKey: entry.publicKey,
+    provider
+  };
+}
+// src/chains/definitions.ts
+var mainnet = {
+  id: 1,
+  name: "Stacks Mainnet",
+  network: "mainnet",
+  transactionVersion: 0,
+  peerNetworkId: 385875968,
+  addressVersion: { singleSig: 22, multiSig: 20 },
+  magicBytes: "X2",
+  bootAddress: "SP000000000000000000002Q6VF78",
+  nativeCurrency: { name: "Stacks", symbol: "STX", decimals: 6 },
+  rpcUrls: {
+    default: {
+      http: ["https://api.mainnet.hiro.so"],
+      ws: ["wss://api.mainnet.hiro.so/extended/v1/ws"]
+    }
+  },
+  blockExplorers: {
+    default: { name: "Hiro Explorer", url: "https://explorer.hiro.so" }
+  }
+};
+var testnet = {
+  id: 2147483648,
+  name: "Stacks Testnet",
+  network: "testnet",
+  transactionVersion: 128,
+  peerNetworkId: 4278190080,
+  addressVersion: { singleSig: 26, multiSig: 21 },
+  magicBytes: "T2",
+  bootAddress: "ST000000000000000000002AMW42H",
+  nativeCurrency: { name: "Stacks", symbol: "STX", decimals: 6 },
+  rpcUrls: {
+    default: {
+      http: ["https://api.testnet.hiro.so"],
+      ws: ["wss://api.testnet.hiro.so/extended/v1/ws"]
+    }
+  },
+  blockExplorers: {
+    default: {
+      name: "Hiro Explorer",
+      url: "https://explorer.hiro.so/?chain=testnet"
+    }
+  }
+};
+var devnet = {
+  id: 2147483648,
+  name: "Stacks Devnet",
+  network: "testnet",
+  transactionVersion: 128,
+  peerNetworkId: 4278190080,
+  addressVersion: { singleSig: 26, multiSig: 21 },
+  magicBytes: "id",
+  bootAddress: "ST000000000000000000002AMW42H",
+  nativeCurrency: { name: "Stacks", symbol: "STX", decimals: 6 },
+  rpcUrls: {
+    default: {
+      http: ["http://localhost:3999"],
+      ws: ["ws://localhost:3999/extended/v1/ws"]
+    }
+  }
+};
+var mocknet = {
+  ...devnet,
+  name: "Stacks Mocknet",
+  addressVersion: { ...devnet.addressVersion }
+};
+// src/chains/defineChain.ts
+function defineChain(chain) {
+  return chain;
+}
+// src/utils/units.ts
+function formatUnits(value, decimals) {
+  let v = BigInt(value);
+  const negative = v < 0n;
+  if (negative)
+    v = -v;
+  const divisor = 10n ** BigInt(decimals);
+  const integer = (v / divisor).toString();
+  let fraction = (v % divisor).toString().padStart(decimals, "0");
+  fraction = fraction.replace(/0+$/, "") || "0";
+  const result = `${integer}.${fraction}`;
+  return negative ? `-${result}` : result;
+}
+var DECIMAL_STRING = /^-?\d+(\.\d+)?$/;
+function parseUnits(value, decimals) {
+  if (typeof value === "number" && !Number.isFinite(value)) {
+    throw new RangeError(`Cannot parse ${value} as a decimal amount`);
+  }
+  let str = typeof value === "number" ? value.toFixed(decimals) : value.trim();
+  if (!DECIMAL_STRING.test(str)) {
+    throw new RangeError(`Cannot parse "${value}" as a decimal amount: expected digits with an optional fraction, like "1.5"`);
+  }
+  if (typeof value === "number" && Number(str) !== value) {
+    throw new RangeError(`Cannot parse ${value} with ${decimals} decimals: pass the amount as a string to keep every digit`);
+  }
+  const negative = str.startsWith("-");
+  if (negative)
+    str = str.slice(1);
+  const [integer = "", fraction = ""] = str.split(".");
+  if (fraction.length > decimals) {
+    throw new Error(`Too many decimal places: "${value}" has ${fraction.length} decimals, max is ${decimals}`);
+  }
+  const padded = fraction.padEnd(decimals, "0");
+  const result = BigInt(integer + padded);
+  return negative ? -result : result;
+}
+function formatStx(microStx) {
+  return formatUnits(microStx, 6);
+}
+function parseStx(stx) {
+  return parseUnits(stx, 6);
+}
 
-//# debugId=7288BF2DFC74BFCE64756E2164756E21
+//# debugId=3FA35CAE5C34437464756E2164756E21
 //# sourceMappingURL=index.cjs.map