@secondlayer/stacks 5.1.3 → 6.0.0

package/dist/src/tools/index.js

@@ -1,3827 +0,0 @@
-// src/tools/index.ts
-import { tool } from "ai";
-import { z } from "zod";
-
-// 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/utils/c32.ts
-import { sha256 } from "@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 writeUInt16BE(value) {
-  const buf = new Uint8Array(2);
-  buf[0] = value >>> 8 & 255;
-  buf[1] = value & 255;
-  return buf;
-}
-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(sha256(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/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, hash160] = c32addressDecode(c32Address);
-  return concatBytes(new Uint8Array([version]), hexToBytes(hash160));
-}
-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");
-  }
-}
-
-// 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 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 RECOVERABLE_ECDSA_SIG_LENGTH_BYTES = 65;
-var MEMO_MAX_LENGTH_BYTES = 34;
-var COINBASE_BYTES_LENGTH = 32;
-var VRF_PROOF_BYTES_LENGTH = 80;
-var MICROBLOCK_HEADER_BYTES_LENGTH = 132;
-
-// src/transactions/wire/serialize.ts
-function serializeAddress2(c32Address) {
-  const [version, hash160] = c32addressDecode(c32Address);
-  return concatBytes(new Uint8Array([version]), hexToBytes(hash160));
-}
-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;
-}
-
-// 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/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/errors/transaction.ts
-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";
-}
-
-// 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/utils/constants.ts
-var MAX_U128 = (1n << 128n) - 1n;
-var MAX_I128 = (1n << 127n) - 1n;
-var MIN_I128 = -(1n << 127n);
-var AddressVersion = {
-  MainnetSingleSig: 22,
-  MainnetMultiSig: 20,
-  TestnetSingleSig: 26,
-  TestnetMultiSig: 21
-};
-
-// src/utils/hash.ts
-import { ripemd160 } from "@noble/hashes/legacy.js";
-import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
-import { sha512_256 } from "@noble/hashes/sha2.js";
-function hash160(input) {
-  return ripemd160(sha2562(input));
-}
-function txidFromBytes(data) {
-  return bytesToHex(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;
-  }
-}
-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;
-}
-
-// 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));
-}
-
-// 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/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
-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
-        }
-      };
-    }
-  };
-}
-
-// 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/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/clarity/abi/utils.ts
-function toCamelCase(str) {
-  return str.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase()).replace(/-([A-Z])/g, (_, letter) => letter).replace(/-(\d)/g, (_, digit) => digit).replace(/-/g, "").replace(/^\d/, "_$&");
-}
-// src/clarity/abi/guards.ts
-function isAbiList(type) {
-  return typeof type === "object" && type !== null && "list" in type;
-}
-function isAbiTuple(type) {
-  return typeof type === "object" && type !== null && "tuple" in type;
-}
-function isAbiOptional(type) {
-  return typeof type === "object" && type !== null && "optional" in type;
-}
-function isAbiResponse(type) {
-  return typeof type === "object" && type !== null && "response" in type;
-}
-function isAbiBuffer(type) {
-  return typeof type === "object" && type !== null && "buff" in type;
-}
-function isAbiStringAscii(type) {
-  return typeof type === "object" && type !== null && "string-ascii" in type;
-}
-function isAbiStringUtf8(type) {
-  return typeof type === "object" && type !== null && "string-utf8" in type;
-}
-
-// src/clarity/bridge.ts
-var CV_TYPE_TAGS = new Set([
-  "int",
-  "uint",
-  "true",
-  "false",
-  "address",
-  "contract",
-  "ascii",
-  "utf8",
-  "buffer",
-  "list",
-  "tuple",
-  "none",
-  "some",
-  "ok",
-  "err"
-]);
-function isClarityValue(value) {
-  if (typeof value !== "object" || value === null)
-    return false;
-  const type = value.type;
-  if (typeof type !== "string" || !CV_TYPE_TAGS.has(type))
-    return false;
-  if (type === "true" || type === "false" || type === "none")
-    return true;
-  return "value" in value;
-}
-var HEX_PAIRS_REGEX = /^(?:[0-9a-fA-F]{2})+$/;
-function coerceBuffer(value) {
-  if (value instanceof Uint8Array)
-    return bufferCV(value);
-  if (typeof value === "object" && value !== null && "type" in value) {
-    const tagged = value;
-    if (tagged.type === "buffer" && isClarityValue(value))
-      return value;
-    if (typeof tagged.value === "string") {
-      if (tagged.type === "ascii")
-        return Cl.bufferFromAscii(tagged.value);
-      if (tagged.type === "utf8")
-        return Cl.bufferFromUtf8(tagged.value);
-      if (tagged.type === "hex")
-        return Cl.bufferFromHex(tagged.value);
-    }
-    throw new Error(`Unsupported buffer input: ${JSON.stringify(value)}`);
-  }
-  if (typeof value === "string") {
-    const hex = value.startsWith("0x") ? value.slice(2) : value;
-    if (HEX_PAIRS_REGEX.test(hex))
-      return Cl.bufferFromHex(hex);
-    return Cl.bufferFromUtf8(value);
-  }
-  throw new Error("buffer arg expects Uint8Array, hex string, { type, value }, or BufferCV");
-}
-function jsToClarityValue(abiType, value) {
-  if (isAbiBuffer(abiType))
-    return coerceBuffer(value);
-  if (isClarityValue(value))
-    return value;
-  if (abiType === "uint128")
-    return uintCV(value);
-  if (abiType === "int128")
-    return intCV(value);
-  if (abiType === "bool")
-    return boolCV(value);
-  if (abiType === "principal" || abiType === "trait_reference")
-    return Cl.principal(value);
-  if (isAbiStringAscii(abiType))
-    return stringAsciiCV(value);
-  if (isAbiStringUtf8(abiType))
-    return stringUtf8CV(value);
-  if (isAbiList(abiType)) {
-    const arr = value;
-    return listCV(arr.map((item) => jsToClarityValue(abiType.list.type, item)));
-  }
-  if (isAbiTuple(abiType)) {
-    const obj = value;
-    const data = {};
-    for (const field of abiType.tuple) {
-      const camelKey = toCamelCase(field.name);
-      const hasOriginal = field.name in obj;
-      const hasCamel = camelKey in obj;
-      const fieldValue = hasOriginal ? obj[field.name] : hasCamel ? obj[camelKey] : undefined;
-      if (fieldValue === undefined && !isAbiOptional(field.type)) {
-        throw new Error(`Missing tuple field: ${field.name}`);
-      }
-      data[field.name] = jsToClarityValue(field.type, fieldValue);
-    }
-    return tupleCV(data);
-  }
-  if (isAbiOptional(abiType)) {
-    if (value === null || value === undefined)
-      return noneCV();
-    return someCV(jsToClarityValue(abiType.optional, value));
-  }
-  if (isAbiResponse(abiType)) {
-    const obj = value;
-    if ("ok" in obj && !("err" in obj))
-      return responseOkCV(jsToClarityValue(abiType.response.ok, obj.ok));
-    if ("err" in obj && !("ok" in obj))
-      return responseErrorCV(jsToClarityValue(abiType.response.error, obj.err));
-    throw new Error("Response must have exactly 'ok' or 'err' property");
-  }
-  throw new Error(`Unknown ABI type: ${JSON.stringify(abiType)}`);
-}
-function clarityValueToJSUntyped(abiType, cv) {
-  return clarityValueToJSInner(abiType, cv);
-}
-function clarityValueToJSInner(abiType, cv) {
-  if (abiType === "uint128" || abiType === "int128") {
-    if (cv.type !== "int" && cv.type !== "uint")
-      throw new Error(`Expected int/uint CV, got ${cv.type}`);
-    return cv.value;
-  }
-  if (abiType === "bool") {
-    if (cv.type === "true")
-      return true;
-    if (cv.type === "false")
-      return false;
-    throw new Error(`Expected bool CV, got ${cv.type}`);
-  }
-  if (abiType === "principal" || abiType === "trait_reference") {
-    if (cv.type !== "address" && cv.type !== "contract")
-      throw new Error(`Expected principal CV, got ${cv.type}`);
-    return cv.value;
-  }
-  if (isAbiStringAscii(abiType) || isAbiStringUtf8(abiType)) {
-    if (cv.type !== "ascii" && cv.type !== "utf8")
-      throw new Error(`Expected string CV, got ${cv.type}`);
-    return cv.value;
-  }
-  if (isAbiBuffer(abiType)) {
-    if (cv.type !== "buffer")
-      throw new Error(`Expected buffer CV, got ${cv.type}`);
-    const hex = cv.value;
-    const bytes = new Uint8Array(hex.length / 2);
-    for (let i = 0;i < bytes.length; i++) {
-      bytes[i] = Number.parseInt(hex.substring(i * 2, i * 2 + 2), 16);
-    }
-    return bytes;
-  }
-  if (isAbiList(abiType)) {
-    if (cv.type !== "list")
-      throw new Error(`Expected list CV, got ${cv.type}`);
-    return cv.value.map((item) => clarityValueToJSInner(abiType.list.type, item));
-  }
-  if (isAbiTuple(abiType)) {
-    if (cv.type !== "tuple")
-      throw new Error(`Expected tuple CV, got ${cv.type}`);
-    const result = {};
-    for (const field of abiType.tuple) {
-      const fieldCV = cv.value[field.name];
-      if (!fieldCV)
-        throw new Error(`Missing tuple field in CV: ${field.name}`);
-      const camelKey = toCamelCase(field.name);
-      result[camelKey] = clarityValueToJSInner(field.type, fieldCV);
-    }
-    return result;
-  }
-  if (isAbiOptional(abiType)) {
-    if (cv.type === "none")
-      return null;
-    if (cv.type === "some")
-      return clarityValueToJSInner(abiType.optional, cv.value);
-    throw new Error(`Expected optional CV, got ${cv.type}`);
-  }
-  if (isAbiResponse(abiType)) {
-    if (cv.type === "ok")
-      return { ok: clarityValueToJSInner(abiType.response.ok, cv.value) };
-    if (cv.type === "err")
-      return { err: clarityValueToJSInner(abiType.response.error, cv.value) };
-    throw new Error(`Expected response CV, got ${cv.type}`);
-  }
-  throw new Error(`Unknown ABI type: ${JSON.stringify(abiType)}`);
-}
-
-// 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));
-}
-
-// src/transactions/authorization.ts
-import { hmac } from "@noble/hashes/hmac.js";
-import { sha256 as sha2563 } from "@noble/hashes/sha2.js";
-import { etc, getPublicKey as nobleGetPublicKey, sign } from "@noble/secp256k1";
-etc.hmacSha256Sync = (key, ...msgs) => {
-  const h = hmac.create(sha2563, 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);
-}
-
-// src/transactions/multisig.ts
-import {
-  getPublicKey as nobleGetPublicKey2,
-  sign as nobleSign
-} from "@noble/secp256k1";
-var OP_CHECKMULTISIG = 174;
-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 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
-  };
-}
-
-// 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 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
-    }
-  };
-  if (options.publicKeys) {
-    tx._multisig = { publicKeys: options.publicKeys };
-  }
-  return tx;
-}
-
-// 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/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/transactions/signer.ts
-function txid(tx) {
-  return txidFromBytes(serializeTransaction(tx));
-}
-function signBegin(tx) {
-  const cleared = {
-    ...tx,
-    auth: intoInitialSighashAuth(tx.auth)
-  };
-  return txid(cleared);
-}
-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);
-}
-
-// src/actions/public/waitForTransactionReceipt.ts
-var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
-async function waitForTransactionReceipt(client, params) {
-  const {
-    txid: txid2,
-    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: txid2 });
-    const receipt = snapshot.receipt;
-    if (receipt === null) {
-      unknownSince ??= Date.now();
-      if (Date.now() - unknownSince >= droppedGracePeriod) {
-        throw new TransactionDroppedError(everPending ? `Transaction ${txid2} left the mempool without being mined` : `Transaction ${txid2} was never observed by the status source`, { txid: txid2 });
-      }
-    } else {
-      unknownSince = null;
-      switch (receipt.status) {
-        case "dropped":
-          throw new TransactionDroppedError(`Transaction ${txid2} was dropped from the mempool`, { txid: txid2 });
-        case "abort_by_response":
-        case "abort_by_post_condition":
-          throw new TransactionAbortedError(`Transaction ${txid2} 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 ${txid2}`, { txid: txid2 });
-    }
-    await sleep2(pollingInterval);
-  }
-}
-
-// 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
-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 {}
-}
-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/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/getContract.ts
-function getContract(params) {
-  const { client, address, name: contractName, abi } = params;
-  const contractId = `${address}.${contractName}`;
-  const fnByName = new Map;
-  for (const fn of abi.functions) {
-    fnByName.set(fn.name, fn);
-  }
-  const mapByName = new Map;
-  if (abi.maps) {
-    for (const m of abi.maps) {
-      mapByName.set(m.name, m);
-    }
-  }
-  const camelToKebab = new Map;
-  for (const fn of abi.functions) {
-    camelToKebab.set(toCamelCase(fn.name), fn.name);
-  }
-  if (abi.maps) {
-    for (const m of abi.maps) {
-      camelToKebab.set(toCamelCase(m.name), m.name);
-    }
-  }
-  const read = new Proxy({}, {
-    get(_target, prop) {
-      const fnName = camelToKebab.get(prop) ?? prop;
-      const fn = fnByName.get(fnName);
-      if (!fn || fn.access !== "read-only")
-        return;
-      return async (args = {}) => {
-        const clarityArgs = buildFunctionArgs(fn, args);
-        const result = await readContract(client, {
-          contract: contractId,
-          functionName: fn.name,
-          args: clarityArgs
-        });
-        const jsValue = clarityValueToJSUntyped(fn.outputs, result);
-        if (isResponseOutput(fn.outputs)) {
-          const resp = jsValue;
-          if ("ok" in resp)
-            return resp.ok;
-          throw new ContractResponseError(`${contractId}::${fn.name} returned (err ${formatErrValue(resp.err)})`, resp.err);
-        }
-        return jsValue;
-      };
-    }
-  });
-  const call = new Proxy({}, {
-    get(_target, prop) {
-      const fnName = camelToKebab.get(prop) ?? prop;
-      const fn = fnByName.get(fnName);
-      if (!fn || fn.access !== "public")
-        return;
-      return async (args = {}, options) => {
-        const clarityArgs = buildFunctionArgs(fn, args);
-        return callContract(client, {
-          contract: contractId,
-          functionName: fn.name,
-          functionArgs: clarityArgs,
-          ...options
-        });
-      };
-    }
-  });
-  const buildCall = new Proxy({}, {
-    get(_target, prop) {
-      const fnName = camelToKebab.get(prop) ?? prop;
-      const fn = fnByName.get(fnName);
-      if (!fn || fn.access !== "public")
-        return;
-      return async (args = {}, options) => {
-        const publicKey = options?.publicKey ?? client.account?.publicKey;
-        if (!publicKey) {
-          throw new Error("buildCall requires a publicKey (pass options.publicKey or configure a client account)");
-        }
-        const functionArgs = buildFunctionArgs(fn, args);
-        const network = client.chain?.network ?? "mainnet";
-        const nonce = options?.nonce ?? await getNonce(client, {
-          address: publicKeyToAddress(publicKey, network)
-        });
-        const unsigned = buildContractCall({
-          contractAddress: address,
-          contractName,
-          functionName: fn.name,
-          functionArgs,
-          fee: options?.fee ?? 0n,
-          nonce,
-          publicKey,
-          chain: client.chain,
-          postConditionMode: options?.postConditionMode,
-          postConditions: options?.postConditions,
-          sponsored: options?.sponsored
-        });
-        if (options?.fee === undefined) {
-          const { fee } = await resolveFee(client, unsigned, undefined);
-          setUnsignedFee(unsigned, fee);
-        }
-        return unsigned;
-      };
-    }
-  });
-  const maps = new Proxy({}, {
-    get(_target, prop) {
-      const mapName = camelToKebab.get(prop) ?? prop;
-      const map = mapByName.get(mapName);
-      if (!map)
-        return;
-      return async (key) => {
-        const clarityKey = jsToClarityValue(map.key, key);
-        const result = await getMapEntry(client, {
-          contract: contractId,
-          mapName: map.name,
-          key: clarityKey
-        });
-        if (result.type === "none")
-          return null;
-        if (result.type === "some") {
-          return clarityValueToJSUntyped(map.value, result.value);
-        }
-        return clarityValueToJSUntyped(map.value, result);
-      };
-    }
-  });
-  return { read, call, buildCall, maps };
-}
-function resolveNetworkContract(client, contracts) {
-  if (!client.chain) {
-    throw new Error("Client must have a chain configured");
-  }
-  return contracts[client.chain.network];
-}
-function buildFunctionArgs(fn, args = {}) {
-  return fn.args.map((arg) => {
-    const camelKey = toCamelCase(arg.name);
-    const hasOriginal = arg.name in args;
-    const hasCamel = camelKey in args;
-    const value = hasOriginal ? args[arg.name] : hasCamel ? args[camelKey] : undefined;
-    if (value === undefined)
-      throw new Error(`Missing argument: ${arg.name}`);
-    return jsToClarityValue(arg.type, value);
-  });
-}
-function isResponseOutput(type) {
-  return typeof type === "object" && type !== null && "response" in type;
-}
-function formatErrValue(value) {
-  if (typeof value === "bigint")
-    return value.toString();
-  if (typeof value === "string")
-    return `"${value}"`;
-  return String(value);
-}
-
-class ContractResponseError extends Error {
-  errorValue;
-  name = "ContractResponseError";
-  constructor(message, errorValue) {
-    super(message);
-    this.errorValue = errorValue;
-  }
-}
-// src/clarity/structuredData.ts
-import { sha256 as sha2564 } from "@noble/hashes/sha2.js";
-var SIP018_PREFIX = new Uint8Array([
-  83,
-  73,
-  80,
-  48,
-  49,
-  56
-]);
-// src/clarity/prettyPrint.ts
-function cvToJSON(val) {
-  switch (val.type) {
-    case "true":
-      return { type: "bool", value: true };
-    case "false":
-      return { type: "bool", value: false };
-    case "int":
-      return { type: "int", value: val.value.toString() };
-    case "uint":
-      return { type: "uint", value: val.value.toString() };
-    case "buffer": {
-      const hex = without0x(val.value);
-      return {
-        type: `(buff ${Math.ceil(hex.length / 2)})`,
-        value: `0x${hex}`
-      };
-    }
-    case "none":
-      return { type: "(optional none)", value: null };
-    case "some":
-      return { type: "(optional)", value: cvToJSON(val.value) };
-    case "ok":
-      return { type: "(response)", value: cvToJSON(val.value), success: true };
-    case "err":
-      return { type: "(response)", value: cvToJSON(val.value), success: false };
-    case "address":
-    case "contract":
-      return { type: "principal", value: val.value };
-    case "list":
-      return { type: "(list)", value: val.value.map(cvToJSON) };
-    case "tuple": {
-      const result = {};
-      for (const key of Object.keys(val.value)) {
-        result[key] = cvToJSON(val.value[key]);
-      }
-      return { type: "(tuple)", value: result };
-    }
-    case "ascii":
-      return {
-        type: `(string-ascii ${asciiToBytes(val.value).length})`,
-        value: val.value
-      };
-    case "utf8":
-      return {
-        type: `(string-utf8 ${utf8ToBytes(val.value).length})`,
-        value: val.value
-      };
-  }
-}
-// src/clarity/abi/standards.ts
-var SIP010_ABI = {
-  functions: [
-    {
-      name: "transfer",
-      access: "public",
-      args: [
-        { name: "amount", type: "uint128" },
-        { name: "sender", type: "principal" },
-        { name: "recipient", type: "principal" },
-        { name: "memo", type: { optional: { buff: { length: 34 } } } }
-      ],
-      outputs: { response: { ok: "bool", error: "uint128" } }
-    },
-    {
-      name: "get-balance",
-      access: "read-only",
-      args: [{ name: "account", type: "principal" }],
-      outputs: { response: { ok: "uint128", error: "uint128" } }
-    },
-    {
-      name: "get-total-supply",
-      access: "read-only",
-      args: [],
-      outputs: { response: { ok: "uint128", error: "uint128" } }
-    },
-    {
-      name: "get-name",
-      access: "read-only",
-      args: [],
-      outputs: {
-        response: {
-          ok: { "string-ascii": { length: 32 } },
-          error: "uint128"
-        }
-      }
-    },
-    {
-      name: "get-symbol",
-      access: "read-only",
-      args: [],
-      outputs: {
-        response: {
-          ok: { "string-ascii": { length: 10 } },
-          error: "uint128"
-        }
-      }
-    },
-    {
-      name: "get-decimals",
-      access: "read-only",
-      args: [],
-      outputs: { response: { ok: "uint128", error: "uint128" } }
-    },
-    {
-      name: "get-token-uri",
-      access: "read-only",
-      args: [],
-      outputs: {
-        response: {
-          ok: { optional: { "string-utf8": { length: 256 } } },
-          error: "uint128"
-        }
-      }
-    }
-  ],
-  fungible_tokens: [{ name: "token" }]
-};
-var SIP009_ABI = {
-  functions: [
-    {
-      name: "transfer",
-      access: "public",
-      args: [
-        { name: "id", type: "uint128" },
-        { name: "sender", type: "principal" },
-        { name: "recipient", type: "principal" }
-      ],
-      outputs: { response: { ok: "bool", error: "uint128" } }
-    },
-    {
-      name: "get-owner",
-      access: "read-only",
-      args: [{ name: "id", type: "uint128" }],
-      outputs: {
-        response: { ok: { optional: "principal" }, error: "uint128" }
-      }
-    },
-    {
-      name: "get-last-token-id",
-      access: "read-only",
-      args: [],
-      outputs: { response: { ok: "uint128", error: "uint128" } }
-    },
-    {
-      name: "get-token-uri",
-      access: "read-only",
-      args: [{ name: "id", type: "uint128" }],
-      outputs: {
-        response: {
-          ok: { optional: { "string-utf8": { length: 256 } } },
-          error: "uint128"
-        }
-      }
-    }
-  ],
-  non_fungible_tokens: [{ name: "nft", type: "uint128" }]
-};
-var SIP013_ABI = {
-  functions: [
-    {
-      name: "transfer",
-      access: "public",
-      args: [
-        { name: "token-id", type: "uint128" },
-        { name: "amount", type: "uint128" },
-        { name: "sender", type: "principal" },
-        { name: "recipient", type: "principal" }
-      ],
-      outputs: { response: { ok: "bool", error: "uint128" } }
-    },
-    {
-      name: "transfer-memo",
-      access: "public",
-      args: [
-        { name: "token-id", type: "uint128" },
-        { name: "amount", type: "uint128" },
-        { name: "sender", type: "principal" },
-        { name: "recipient", type: "principal" },
-        { name: "memo", type: { buff: { length: 34 } } }
-      ],
-      outputs: { response: { ok: "bool", error: "uint128" } }
-    },
-    {
-      name: "transfer-many",
-      access: "public",
-      args: [
-        {
-          name: "transfers",
-          type: {
-            list: {
-              type: {
-                tuple: [
-                  { name: "token-id", type: "uint128" },
-                  { name: "amount", type: "uint128" },
-                  { name: "sender", type: "principal" },
-                  { name: "recipient", type: "principal" }
-                ]
-              },
-              length: 200
-            }
-          }
-        }
-      ],
-      outputs: { response: { ok: "bool", error: "uint128" } }
-    },
-    {
-      name: "transfer-many-memo",
-      access: "public",
-      args: [
-        {
-          name: "transfers",
-          type: {
-            list: {
-              type: {
-                tuple: [
-                  { name: "token-id", type: "uint128" },
-                  { name: "amount", type: "uint128" },
-                  { name: "sender", type: "principal" },
-                  { name: "recipient", type: "principal" },
-                  { name: "memo", type: { buff: { length: 34 } } }
-                ]
-              },
-              length: 200
-            }
-          }
-        }
-      ],
-      outputs: { response: { ok: "bool", error: "uint128" } }
-    },
-    {
-      name: "get-balance",
-      access: "read-only",
-      args: [
-        { name: "token-id", type: "uint128" },
-        { name: "account", type: "principal" }
-      ],
-      outputs: { response: { ok: "uint128", error: "uint128" } }
-    },
-    {
-      name: "get-overall-balance",
-      access: "read-only",
-      args: [{ name: "account", type: "principal" }],
-      outputs: { response: { ok: "uint128", error: "uint128" } }
-    },
-    {
-      name: "get-total-supply",
-      access: "read-only",
-      args: [{ name: "token-id", type: "uint128" }],
-      outputs: { response: { ok: "uint128", error: "uint128" } }
-    },
-    {
-      name: "get-overall-supply",
-      access: "read-only",
-      args: [],
-      outputs: { response: { ok: "uint128", error: "uint128" } }
-    },
-    {
-      name: "get-decimals",
-      access: "read-only",
-      args: [{ name: "token-id", type: "uint128" }],
-      outputs: { response: { ok: "uint128", error: "uint128" } }
-    },
-    {
-      name: "get-token-uri",
-      access: "read-only",
-      args: [{ name: "token-id", type: "uint128" }],
-      outputs: {
-        response: {
-          ok: { optional: { "string-utf8": { length: 256 } } },
-          error: "uint128"
-        }
-      }
-    }
-  ],
-  fungible_tokens: [],
-  non_fungible_tokens: []
-};
-// src/clarity/abi/classify.ts
-var STANDARDS = [
-  { id: "sip-010", abi: SIP010_ABI, optional: new Set(["get-token-uri"]) },
-  { id: "sip-009", abi: SIP009_ABI, optional: new Set(["get-token-uri"]) },
-  {
-    id: "sip-013",
-    abi: SIP013_ABI,
-    optional: new Set([
-      "transfer-memo",
-      "transfer-many",
-      "transfer-many-memo",
-      "get-token-uri",
-      "get-overall-balance",
-      "get-overall-supply"
-    ])
-  }
-];
-// src/bns/abi.ts
-var BNS_ABI = {
-  functions: [
-    {
-      name: "get-owner-name",
-      access: "read-only",
-      args: [
-        { name: "name", type: { buff: { length: 48 } } },
-        { name: "namespace", type: { buff: { length: 20 } } }
-      ],
-      outputs: {
-        response: {
-          ok: { optional: "principal" },
-          error: "uint128"
-        }
-      }
-    },
-    {
-      name: "get-id-from-bns",
-      access: "read-only",
-      args: [
-        { name: "name", type: { buff: { length: 48 } } },
-        { name: "namespace", type: { buff: { length: 20 } } }
-      ],
-      outputs: { optional: "uint128" }
-    },
-    {
-      name: "get-bns-from-id",
-      access: "read-only",
-      args: [{ name: "id", type: "uint128" }],
-      outputs: {
-        optional: {
-          tuple: [
-            { name: "name", type: { buff: { length: 48 } } },
-            { name: "namespace", type: { buff: { length: 20 } } }
-          ]
-        }
-      }
-    },
-    {
-      name: "get-owner",
-      access: "read-only",
-      args: [{ name: "id", type: "uint128" }],
-      outputs: {
-        response: {
-          ok: { optional: "principal" },
-          error: "none"
-        }
-      }
-    },
-    {
-      name: "get-primary",
-      access: "read-only",
-      args: [{ name: "owner", type: "principal" }],
-      outputs: {
-        response: {
-          ok: {
-            optional: {
-              tuple: [
-                { name: "name", type: { buff: { length: 48 } } },
-                { name: "namespace", type: { buff: { length: 20 } } }
-              ]
-            }
-          },
-          error: "none"
-        }
-      }
-    },
-    {
-      name: "can-resolve-name",
-      access: "read-only",
-      args: [
-        { name: "namespace", type: { buff: { length: 20 } } },
-        { name: "name", type: { buff: { length: 48 } } }
-      ],
-      outputs: {
-        response: {
-          ok: {
-            tuple: [
-              { name: "renewal", type: "uint128" },
-              { name: "owner", type: "principal" }
-            ]
-          },
-          error: "uint128"
-        }
-      }
-    },
-    {
-      name: "get-renewal-height",
-      access: "read-only",
-      args: [{ name: "id", type: "uint128" }],
-      outputs: { response: { ok: "uint128", error: "uint128" } }
-    },
-    {
-      name: "get-name-price",
-      access: "read-only",
-      args: [
-        { name: "namespace", type: { buff: { length: 20 } } },
-        { name: "name", type: { buff: { length: 48 } } }
-      ],
-      outputs: {
-        response: {
-          ok: { response: { ok: "uint128", error: "uint128" } },
-          error: "uint128"
-        }
-      }
-    },
-    {
-      name: "get-bns-info",
-      access: "read-only",
-      args: [
-        { name: "name", type: { buff: { length: 48 } } },
-        { name: "namespace", type: { buff: { length: 20 } } }
-      ],
-      outputs: {
-        optional: {
-          tuple: [
-            {
-              name: "hashed-salted-fqn-preorder",
-              type: { optional: { buff: { length: 20 } } }
-            },
-            { name: "imported-at", type: { optional: "uint128" } },
-            { name: "owner", type: "principal" },
-            { name: "preordered-by", type: { optional: "principal" } },
-            { name: "registered-at", type: { optional: "uint128" } },
-            { name: "renewal-height", type: "uint128" },
-            { name: "stx-burn", type: "uint128" }
-          ]
-        }
-      }
-    },
-    {
-      name: "name-preorder",
-      access: "public",
-      args: [
-        { name: "hashed-salted-fqn", type: { buff: { length: 20 } } },
-        { name: "stx-to-burn", type: "uint128" }
-      ],
-      outputs: { response: { ok: "uint128", error: "uint128" } }
-    },
-    {
-      name: "name-register",
-      access: "public",
-      args: [
-        { name: "namespace", type: { buff: { length: 20 } } },
-        { name: "name", type: { buff: { length: 48 } } },
-        { name: "salt", type: { buff: { length: 20 } } }
-      ],
-      outputs: { response: { ok: "uint128", error: "uint128" } }
-    },
-    {
-      name: "name-claim-fast",
-      access: "public",
-      args: [
-        { name: "name", type: { buff: { length: 48 } } },
-        { name: "namespace", type: { buff: { length: 20 } } },
-        { name: "send-to", type: "principal" }
-      ],
-      outputs: { response: { ok: "uint128", error: "uint128" } }
-    },
-    {
-      name: "name-renewal",
-      access: "public",
-      args: [
-        { name: "namespace", type: { buff: { length: 20 } } },
-        { name: "name", type: { buff: { length: 48 } } }
-      ],
-      outputs: { response: { ok: "bool", error: "uint128" } }
-    },
-    {
-      name: "transfer",
-      access: "public",
-      args: [
-        { name: "id", type: "uint128" },
-        { name: "owner", type: "principal" },
-        { name: "recipient", type: "principal" }
-      ],
-      outputs: { response: { ok: "bool", error: "uint128" } }
-    },
-    {
-      name: "set-primary-name",
-      access: "public",
-      args: [{ name: "primary-name-id", type: "uint128" }],
-      outputs: { response: { ok: "bool", error: "uint128" } }
-    }
-  ],
-  non_fungible_tokens: [{ name: "BNS-V2", type: "uint128" }]
-};
-
-// src/bns/constants.ts
-var BNS_CONTRACTS = {
-  mainnet: {
-    address: "SP2QEZ06AGJ3RKJPBV14SY1V5BBFNAW33D96YPGZF",
-    name: "BNS-V2"
-  },
-  testnet: {
-    address: "ST2QEZ06AGJ3RKJPBV14SY1V5BBFNAW33D9SZJQ0M",
-    name: "BNS-V2"
-  }
-};
-var DEFAULT_NAMESPACE = "btc";
-
-// src/bns/utils.ts
-function parseFQN(fqn) {
-  const parts = fqn.split(".");
-  if (parts.length === 1) {
-    return {
-      name: parts[0],
-      namespace: DEFAULT_NAMESPACE
-    };
-  }
-  if (parts.length === 2) {
-    return {
-      name: parts[0],
-      namespace: parts[1]
-    };
-  }
-  throw new Error(`Invalid fully qualified name: ${fqn}. Expected format: "name.namespace" or "name"`);
-}
-function formatFQN(name, namespace) {
-  return `${name}.${namespace}`;
-}
-function validateName(name) {
-  if (name.length < 1 || name.length > 48)
-    return false;
-  const regex = /^[a-z0-9]([a-z0-9_-]*[a-z0-9])?$/;
-  return regex.test(name);
-}
-function validateNamespace(namespace) {
-  if (namespace.length < 1 || namespace.length > 20)
-    return false;
-  const regex = /^[a-z0-9]+$/;
-  return regex.test(namespace);
-}
-function validateFQN(fqn) {
-  try {
-    const { name, namespace } = parseFQN(fqn);
-    return validateName(name) && validateNamespace(namespace);
-  } catch {
-    return false;
-  }
-}
-
-// src/bns/actions.ts
-function getBnsContract(client) {
-  const contract = resolveNetworkContract(client, BNS_CONTRACTS);
-  return getContract({
-    client,
-    address: contract.address,
-    name: contract.name,
-    abi: BNS_ABI
-  });
-}
-function stringToBytes(str) {
-  return new TextEncoder().encode(str);
-}
-async function resolveName(client, nameOrFQN) {
-  if (!validateFQN(nameOrFQN)) {
-    throw new Error(`Invalid name format: ${nameOrFQN}`);
-  }
-  const { name, namespace } = parseFQN(nameOrFQN);
-  const bns = getBnsContract(client);
-  try {
-    return await bns.read.getOwnerName({
-      name: stringToBytes(name),
-      namespace: stringToBytes(namespace)
-    });
-  } catch (e) {
-    if (e instanceof ContractResponseError)
-      return null;
-    throw e;
-  }
-}
-async function getPrimaryName(client, address) {
-  const bns = getBnsContract(client);
-  try {
-    const result = await bns.read.getPrimary({
-      owner: address
-    });
-    if (result === null)
-      return null;
-    const name = new TextDecoder().decode(result.name);
-    const namespace = new TextDecoder().decode(result.namespace);
-    return formatFQN(name, namespace);
-  } catch (e) {
-    if (e instanceof ContractResponseError)
-      return null;
-    throw e;
-  }
-}
-
-// 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/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/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/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/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/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/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/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/transports/http.ts
-function http(url, config) {
-  return (params) => {
-    const resolvedUrl = url ?? params?.chain?.rpcUrls.default.http[0] ?? "http://localhost:3999";
-    const mergedConfig = {
-      ...config,
-      url: resolvedUrl
-    };
-    return createTransport("http", {
-      ...mergedConfig,
-      request: buildRequestFn(resolvedUrl, mergedConfig)
-    });
-  };
-}
-
-// src/tools/client.ts
-var _defaultClient = null;
-function getDefaultPublicClient() {
-  if (_defaultClient)
-    return _defaultClient;
-  const network = process.env.STACKS_NETWORK ?? process.env.STACKS_CHAIN;
-  const chain = network === "testnet" ? testnet : mainnet;
-  const url = process.env.STACKS_NODE_RPC_URL ?? process.env.SL_API_URL ?? process.env.STACKS_RPC_URL;
-  _defaultClient = createPublicClient({
-    chain,
-    transport: http(url)
-  });
-  return _defaultClient;
-}
-
-// src/tools/index.ts
-var PRINCIPAL = z.string().refine((v) => parsePrincipal(v) !== null, {
-  message: "Expected a Stacks principal: a c32 address (SP…/SM… mainnet, ST… testnet), optionally followed by .contract-name"
-}).describe("Stacks principal (SP…/SM… mainnet, ST… testnet)");
-var CONTRACT_ID = z.string().refine((v) => parsePrincipal(v)?.contractName !== undefined, {
-  message: "Expected a contract id in '{address}.{name}' form"
-}).describe("Fully-qualified contract id: '{address}.{name}'");
-var FUNCTION_NAME = z.string().refine(isClarityName, { message: "Expected a Clarity function name" });
-var HASH_32 = /^(0x)?[0-9a-fA-F]{64}$/;
-var TX_ID = z.string().regex(HASH_32, "Expected a 32-byte hex transaction id").describe("Transaction id, with or without 0x prefix");
-var BLOCK_HASH = z.string().regex(HASH_32, "Expected a 32-byte hex block hash");
-async function stxBalance(resolve, principal) {
-  const balance = await getBalance(resolve(), { address: principal });
-  return { microStx: balance.toString() };
-}
-async function accountInfo(resolve, principal) {
-  const info = await getAccountInfo(resolve(), { address: principal });
-  return {
-    balance: info.balance.toString(),
-    nonce: info.nonce.toString()
-  };
-}
-async function block(resolve, args) {
-  return getBlock(resolve(), args);
-}
-async function blockHeight(resolve) {
-  return { height: await getBlockHeight(resolve()) };
-}
-async function contractRead(resolve, args) {
-  const result = await readContract(resolve(), args);
-  return { result: cvToJSON(result) };
-}
-function assertValidHex(raw) {
-  if (raw.length % 2 !== 0) {
-    throw new Error("serializedTxHex: odd-length hex string");
-  }
-  if (!/^[0-9a-fA-F]+$/.test(raw)) {
-    throw new Error("serializedTxHex: contains non-hex characters");
-  }
-}
-async function fee(resolve, serializedTxHex) {
-  const raw = serializedTxHex.startsWith("0x") ? serializedTxHex.slice(2) : serializedTxHex;
-  assertValidHex(raw);
-  const txBytes = hexToBytes(raw);
-  let transaction;
-  try {
-    transaction = deserializeTransaction(txBytes);
-  } catch (e) {
-    throw new Error(`serializedTxHex: deserialization failed: ${e instanceof Error ? e.message : String(e)}`);
-  }
-  const fees = await estimateFee(resolve(), { transaction });
-  if (fees.length === 0) {
-    const min = Number(minimumFee(transaction));
-    return {
-      low: min,
-      medium: min,
-      high: min,
-      source: "min",
-      tiers: 0
-    };
-  }
-  const low = fees[0]?.fee ?? 0;
-  return {
-    low,
-    medium: fees[1]?.fee ?? low,
-    high: fees[2]?.fee ?? fees[1]?.fee ?? low,
-    source: "node",
-    tiers: fees.length
-  };
-}
-async function bnsResolveImpl(resolve, name) {
-  return { owner: await resolveName(resolve(), name) };
-}
-async function bnsReverseImpl(resolve, principal) {
-  return { name: await getPrimaryName(resolve(), principal) };
-}
-async function transactionByTxId(resolve, txId) {
-  const receipt = await getTransaction(resolve(), { txid: txId });
-  if (!receipt)
-    return null;
-  const { result, ...rest } = receipt;
-  return result === undefined ? rest : { ...rest, result: cvToJSON(result) };
-}
-async function accountHistory(resolve, principal, limit) {
-  return getAccountHistory(resolve(), { address: principal, limit });
-}
-async function mempoolStats(resolve) {
-  return getMempoolStats(resolve());
-}
-async function nftHoldings(resolve, principal, limit) {
-  return getNftHoldings(resolve(), { address: principal, limit });
-}
-var EXTENDED = "Needs a host that serves the extended API.";
-function buildTools(resolve) {
-  return {
-    getStxBalance: tool({
-      description: "Get the STX balance (in micro-STX) for a Stacks principal.",
-      inputSchema: z.object({ principal: PRINCIPAL }),
-      execute: ({ principal }) => stxBalance(resolve, principal)
-    }),
-    getAccountInfo: tool({
-      description: "Get the STX balance (micro-STX) and next nonce for a Stacks principal.",
-      inputSchema: z.object({ principal: PRINCIPAL }),
-      execute: ({ principal }) => accountInfo(resolve, principal)
-    }),
-    getBlock: tool({
-      description: "Fetch one Stacks block by height or hash. Omit both for the latest block. Always returns a single block object.",
-      inputSchema: z.object({
-        height: z.number().int().nonnegative().optional(),
-        hash: BLOCK_HASH.optional()
-      }),
-      execute: (args) => block(resolve, args)
-    }),
-    getBlockHeight: tool({
-      description: "Get the current Stacks chain tip height.",
-      inputSchema: z.object({}),
-      execute: () => blockHeight(resolve)
-    }),
-    readContract: tool({
-      description: "Call a read-only Clarity function that takes no arguments. Returns the decoded value as JSON; uint and int arrive as decimal strings.",
-      inputSchema: z.object({
-        contract: CONTRACT_ID,
-        functionName: FUNCTION_NAME,
-        sender: PRINCIPAL.optional()
-      }),
-      execute: (args) => contractRead(resolve, args)
-    }),
-    estimateFee: tool({
-      description: "Estimate fee tiers (low / medium / high, in micro-STX) for a serialized Stacks transaction. `source` is 'node' for a live estimate or 'min' when the node had none and the relay minimum was used. `tiers` is how many estimates the node returned; when it is below 3 the missing tiers repeat the nearest lower one.",
-      inputSchema: z.object({
-        serializedTxHex: z.string().describe("Hex-encoded serialized transaction")
-      }),
-      execute: ({ serializedTxHex }) => fee(resolve, serializedTxHex)
-    }),
-    bnsResolve: tool({
-      description: "Resolve a BNS name (e.g. 'satoshi.btc') to its owning Stacks principal.",
-      inputSchema: z.object({
-        name: z.string().describe("BNS name in 'name.namespace' form")
-      }),
-      execute: ({ name }) => bnsResolveImpl(resolve, name)
-    }),
-    bnsReverse: tool({
-      description: "Reverse-lookup the primary BNS name for a Stacks principal, if set.",
-      inputSchema: z.object({ principal: PRINCIPAL }),
-      execute: ({ principal }) => bnsReverseImpl(resolve, principal)
-    }),
-    getTransaction: tool({
-      description: `Fetch a confirmed Stacks transaction by txId, with its decoded result as JSON. ${EXTENDED}`,
-      inputSchema: z.object({ txId: TX_ID }),
-      execute: ({ txId }) => transactionByTxId(resolve, txId)
-    }),
-    getAccountHistory: tool({
-      description: `List the most recent transactions for a Stacks principal (first page only, up to 50). ${EXTENDED}`,
-      inputSchema: z.object({
-        principal: PRINCIPAL,
-        limit: z.number().int().min(1).max(50).default(20)
-      }),
-      execute: ({ principal, limit }) => accountHistory(resolve, principal, limit)
-    }),
-    getMempoolStats: tool({
-      description: `Current mempool statistics: pending count, fee distribution, age buckets. ${EXTENDED}`,
-      inputSchema: z.object({}),
-      execute: () => mempoolStats(resolve)
-    }),
-    getNftHoldings: tool({
-      description: `List NFTs held by a Stacks principal across all collections (first page only, up to 50). ${EXTENDED}`,
-      inputSchema: z.object({
-        principal: PRINCIPAL,
-        limit: z.number().int().min(1).max(50).default(20)
-      }),
-      execute: ({ principal, limit }) => nftHoldings(resolve, principal, limit)
-    })
-  };
-}
-function createStacksTools(client) {
-  return buildTools(() => client);
-}
-var defaultTools = buildTools(getDefaultPublicClient);
-var getStxBalance = defaultTools.getStxBalance;
-var getAccountInfo2 = defaultTools.getAccountInfo;
-var getBlock2 = defaultTools.getBlock;
-var getBlockHeight2 = defaultTools.getBlockHeight;
-var readContract2 = defaultTools.readContract;
-var estimateFee2 = defaultTools.estimateFee;
-var bnsResolve = defaultTools.bnsResolve;
-var bnsReverse = defaultTools.bnsReverse;
-var getTransaction2 = defaultTools.getTransaction;
-var getAccountHistory2 = defaultTools.getAccountHistory;
-var getMempoolStats2 = defaultTools.getMempoolStats;
-var getNftHoldings2 = defaultTools.getNftHoldings;
-export {
-  readContract2 as readContract,
-  getTransaction2 as getTransaction,
-  getStxBalance,
-  getNftHoldings2 as getNftHoldings,
-  getMempoolStats2 as getMempoolStats,
-  getBlockHeight2 as getBlockHeight,
-  getBlock2 as getBlock,
-  getAccountInfo2 as getAccountInfo,
-  getAccountHistory2 as getAccountHistory,
-  estimateFee2 as estimateFee,
-  createStacksTools,
-  bnsReverse,
-  bnsResolve
-};
-
-//# debugId=BF92A0AEA897CFBD64756E2164756E21
-//# sourceMappingURL=index.js.map