@secondlayer/stacks 6.0.0 → 6.1.0

package/dist/src/bns/index.cjs

@@ -1,18 +1,4440 @@
-// src/bns/index.ts
-var exports_bns = {};
-__export(exports_bns, {
-  validateNamespace: () => validateNamespace,
-  validateName: () => validateName,
-  validateFQN: () => validateFQN,
-  parseFQN: () => parseFQN,
-  hashPreorder: () => hashPreorder,
-  generateSalt: () => generateSalt,
-  formatFQN: () => formatFQN,
-  bns: () => bns,
-  ZONEFILE_RESOLVER_CONTRACTS: () => ZONEFILE_RESOLVER_CONTRACTS,
-  BNS_CONTRACTS: () => BNS_CONTRACTS
+var import_node_module = require("node:module");
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/clarity/index.ts
+var exports_clarity = {};
+__export(exports_clarity, {
+  validateArgsArray: () => validateArgsArray,
+  validateArgs: () => validateArgs,
+  uintCV: () => uintCV,
+  tupleCV: () => tupleCV,
+  trueCV: () => trueCV,
+  toCamelCase: () => toCamelCase,
+  structuredDataHash: () => structuredDataHash,
+  stringUtf8CV: () => stringUtf8CV,
+  stringAsciiCV: () => stringAsciiCV,
+  standardPrincipalCV: () => standardPrincipalCV,
+  someCV: () => someCV,
+  sip013Abi: () => sip013Abi,
+  sip010Abi: () => sip010Abi,
+  sip009Abi: () => sip009Abi,
+  signStructuredData: () => signStructuredData,
+  serializeCVBytes: () => serializeCVBytes,
+  serializeCV: () => serializeCV,
+  responseOkCV: () => responseOkCV,
+  responseErrorCV: () => responseErrorCV,
+  prettyPrint: () => prettyPrint,
+  prepareArgs: () => prepareArgs,
+  parseDeclaredStandards: () => parseDeclaredStandards,
+  normalizeType: () => normalizeType,
+  normalizeAccess: () => normalizeAccess,
+  normalizeAbi: () => normalizeAbi,
+  noneCV: () => noneCV,
+  listCV: () => listCV,
+  jsToClarityValue: () => jsToClarityValue,
+  jsToClarity: () => jsToClarity,
+  isUint8Array: () => isUint8Array,
+  isUint128: () => isUint128,
+  isTraitReference: () => isTraitReference,
+  isString: () => isString,
+  isStandardPrincipal: () => isStandardPrincipal,
+  isResponse: () => isResponse,
+  isPrincipal: () => isPrincipal,
+  isOptional: () => isOptional,
+  isOkResponse: () => isOkResponse,
+  isInt128: () => isInt128,
+  isErrResponse: () => isErrResponse,
+  isContractPrincipal: () => isContractPrincipal,
+  isClarityValue: () => isClarityValue,
+  isBool: () => isBool,
+  isArray: () => isArray,
+  isAbiTuple: () => isAbiTuple,
+  isAbiTraitReference: () => isAbiTraitReference,
+  isAbiStringUtf8: () => isAbiStringUtf8,
+  isAbiStringAscii: () => isAbiStringAscii,
+  isAbiResponse: () => isAbiResponse,
+  isAbiOptional: () => isAbiOptional,
+  isAbiList: () => isAbiList,
+  isAbiBuffer: () => isAbiBuffer,
+  intCV: () => intCV,
+  hashStructuredData: () => hashStructuredData,
+  falseCV: () => falseCV,
+  encodeStructuredData: () => encodeStructuredData,
+  deserializeCVBytes: () => deserializeCVBytes,
+  deserializeCV: () => deserializeCV,
+  cvToValue: () => cvToValue,
+  cvToString: () => cvToString,
+  cvToPrincipal: () => cvToPrincipal,
+  cvToJSON: () => cvToJSON,
+  cvToBuffer: () => cvToBuffer,
+  cvToBoolean: () => cvToBoolean,
+  cvToBigInt: () => cvToBigInt,
+  contractPrincipalCV: () => contractPrincipalCV,
+  classifyContract: () => classifyContract,
+  clarityValueToJSUntyped: () => clarityValueToJSUntyped,
+  clarityValueToJS: () => clarityValueToJS,
+  clarityTypeFromByte: () => clarityTypeFromByte,
+  bufferCV: () => bufferCV,
+  boolCV: () => boolCV,
+  TRAIT_STANDARDS: () => TRAIT_STANDARDS,
+  SIP018_PREFIX: () => SIP018_PREFIX,
+  SIP013_ABI: () => SIP013_ABI,
+  SIP010_ABI: () => SIP010_ABI,
+  SIP009_ABI: () => SIP009_ABI,
+  ClarityWireType: () => ClarityWireType,
+  ClarityConversionError: () => ClarityConversionError,
+  Cl: () => Cl,
+  CONTRACT_NAME_REGEX: () => CONTRACT_NAME_REGEX
 });
-module.exports = __toCommonJS(exports_bns);
+module.exports = __toCommonJS(exports_clarity);
+
+// 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/utils/c32.ts
+var import_sha2 = require("@noble/hashes/sha2.js");
+
+// src/utils/encoding.ts
+var hexes = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+function bytesToHex(bytes) {
+  let hex = "";
+  for (const b of bytes) {
+    hex += hexes[b];
+  }
+  return hex;
+}
+function hexToBytes(hex) {
+  let h = without0x(hex);
+  if (h.length % 2)
+    h = `0${h}`;
+  const array = new Uint8Array(h.length / 2);
+  for (let i = 0;i < array.length; i++) {
+    const j = i * 2;
+    const byte = Number.parseInt(h.slice(j, j + 2), 16);
+    if (Number.isNaN(byte) || byte < 0)
+      throw new Error("Invalid byte sequence");
+    array[i] = byte;
+  }
+  return array;
+}
+function with0x(value) {
+  return /^0x/i.test(value) ? value : `0x${value}`;
+}
+function without0x(value) {
+  return /^0x/i.test(value) ? value.slice(2) : value;
+}
+function utf8ToBytes(str) {
+  return new TextEncoder().encode(str);
+}
+function bytesToUtf8(bytes) {
+  return new TextDecoder().decode(bytes);
+}
+function asciiToBytes(str) {
+  const bytes = new Uint8Array(str.length);
+  for (let i = 0;i < str.length; i++) {
+    bytes[i] = str.charCodeAt(i) & 255;
+  }
+  return bytes;
+}
+function bytesToAscii(bytes) {
+  return String.fromCharCode(...bytes);
+}
+function concatBytes(...arrays) {
+  if (arrays.length === 1)
+    return arrays[0];
+  const length = arrays.reduce((a, arr) => a + arr.length, 0);
+  const result = new Uint8Array(length);
+  let pad = 0;
+  for (const arr of arrays) {
+    result.set(arr, pad);
+    pad += arr.length;
+  }
+  return result;
+}
+function intToBigInt(value) {
+  if (typeof value === "bigint")
+    return value;
+  if (typeof value === "string")
+    return BigInt(value);
+  if (typeof value === "number") {
+    if (!Number.isInteger(value))
+      throw new RangeError("Values of type 'number' must be an integer.");
+    if (value > Number.MAX_SAFE_INTEGER)
+      throw new RangeError(`Values of type 'number' must be <= ${Number.MAX_SAFE_INTEGER}. Use BigInt instead.`);
+    return BigInt(value);
+  }
+  if (value instanceof Uint8Array)
+    return BigInt(`0x${bytesToHex(value)}`);
+  throw new TypeError("Must be a number, bigint, string, or Uint8Array.");
+}
+function intToBytes(value, byteLength) {
+  return bigIntToBytes(intToBigInt(value), byteLength);
+}
+function bigIntToBytes(value, length = 16) {
+  const hex = value.toString(16).padStart(length * 2, "0");
+  return hexToBytes(hex);
+}
+function intToHex(integer, byteLength = 8) {
+  const value = typeof integer === "bigint" ? integer : intToBigInt(integer);
+  return value.toString(16).padStart(byteLength * 2, "0");
+}
+function toTwos(value, width) {
+  const limit = BigInt(1) << width - BigInt(1);
+  if (value < -limit || value > limit - BigInt(1)) {
+    throw new Error(`Unable to represent integer in width: ${width}`);
+  }
+  if (value >= BigInt(0))
+    return value;
+  return value + (BigInt(1) << width);
+}
+function fromTwos(value, width) {
+  if (value & BigInt(1) << width - BigInt(1)) {
+    return value - (BigInt(1) << width);
+  }
+  return value;
+}
+function bytesToTwosBigInt(bytes) {
+  if (bytes.length === 0)
+    return 0n;
+  const hex = bytesToHex(bytes);
+  if (hex.length === 0)
+    return 0n;
+  return fromTwos(BigInt(`0x${hex}`), BigInt(bytes.byteLength * 8));
+}
+function writeUInt32BE(value) {
+  const buf = new Uint8Array(4);
+  buf[0] = value >>> 24 & 255;
+  buf[1] = value >>> 16 & 255;
+  buf[2] = value >>> 8 & 255;
+  buf[3] = value & 255;
+  return buf;
+}
+function readUInt32BE(bytes, offset = 0) {
+  return (bytes[offset] << 24 | bytes[offset + 1] << 16 | bytes[offset + 2] << 8 | bytes[offset + 3]) >>> 0;
+}
+function writeUInt16BE(value) {
+  const buf = new Uint8Array(2);
+  buf[0] = value >>> 8 & 255;
+  buf[1] = value & 255;
+  return buf;
+}
+function readUInt16BE(bytes, offset = 0) {
+  return (bytes[offset] << 8 | bytes[offset + 1]) >>> 0;
+}
+function writeUInt8(value) {
+  return new Uint8Array([value & 255]);
+}
+
+// src/utils/c32.ts
+var C32 = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+var HEX = "0123456789abcdef";
+function c32normalize(input) {
+  return input.toUpperCase().replace(/O/g, "0").replace(/L|I/g, "1");
+}
+function c32encode(inputHex) {
+  let hex = inputHex;
+  if (hex.length % 2 !== 0)
+    hex = `0${hex}`;
+  hex = hex.toLowerCase();
+  const res = [];
+  let carry = 0;
+  for (let i = hex.length - 1;i >= 0; i--) {
+    if (carry < 4) {
+      const currentCode = HEX.indexOf(hex[i]) >> carry;
+      const nextCode = i !== 0 ? HEX.indexOf(hex[i - 1]) : 0;
+      const nextBits = 1 + carry;
+      const nextLowBits = nextCode % (1 << nextBits) << 5 - nextBits;
+      res.unshift(C32[currentCode + nextLowBits]);
+      carry = nextBits;
+    } else {
+      carry = 0;
+    }
+  }
+  let leadingZeros = 0;
+  while (leadingZeros < res.length && res[leadingZeros] === "0")
+    leadingZeros++;
+  const stripped = res.slice(leadingZeros);
+  const bytes = hexToBytes(hex);
+  let zeroBytesCount = 0;
+  while (zeroBytesCount < bytes.length && bytes[zeroBytesCount] === 0)
+    zeroBytesCount++;
+  const prefix = Array(zeroBytesCount).fill(C32[0]);
+  return [...prefix, ...stripped].join("");
+}
+function c32decode(c32input) {
+  const input = c32normalize(c32input);
+  if (!input.match(`^[${C32}]*$`))
+    throw new Error("Not a c32-encoded string");
+  const zeroPrefix = input.match(`^${C32[0]}*`);
+  const numLeadingZeroBytes = zeroPrefix ? zeroPrefix[0]?.length : 0;
+  const res = [];
+  let carry = 0;
+  let carryBits = 0;
+  for (let i = input.length - 1;i >= 0; i--) {
+    if (carryBits === 4) {
+      res.unshift(HEX[carry]);
+      carryBits = 0;
+      carry = 0;
+    }
+    const currentValue = (C32.indexOf(input[i]) << carryBits) + carry;
+    res.unshift(HEX[currentValue % 16]);
+    carryBits += 1;
+    carry = currentValue >> 4;
+    if (carry > 1 << carryBits)
+      throw new Error("Panic error in c32 decoding");
+  }
+  res.unshift(HEX[carry]);
+  if (res.length % 2 === 1)
+    res.unshift("0");
+  let hexLeadingZeros = 0;
+  while (hexLeadingZeros < res.length && res[hexLeadingZeros] === "0")
+    hexLeadingZeros++;
+  let hexStr = res.slice(hexLeadingZeros - hexLeadingZeros % 2).join("");
+  for (let i = 0;i < numLeadingZeroBytes; i++)
+    hexStr = `00${hexStr}`;
+  return hexStr;
+}
+function c32checksum(dataHex) {
+  return bytesToHex(import_sha2.sha256(import_sha2.sha256(hexToBytes(dataHex))).slice(0, 4));
+}
+function c32checkEncode(version, data) {
+  if (version < 0 || version >= 32)
+    throw new Error("Invalid version (must be between 0 and 31)");
+  if (!data.match(/^[0-9a-fA-F]*$/))
+    throw new Error("Invalid data (not a hex string)");
+  let d = data.toLowerCase();
+  if (d.length % 2 !== 0)
+    d = `0${d}`;
+  let versionHex = version.toString(16);
+  if (versionHex.length === 1)
+    versionHex = `0${versionHex}`;
+  const checksumHex = c32checksum(`${versionHex}${d}`);
+  return `${C32[version]}${c32encode(`${d}${checksumHex}`)}`;
+}
+function c32checkDecode(c32data) {
+  const normalized = c32normalize(c32data);
+  const dataHex = c32decode(normalized.slice(1));
+  const version = C32.indexOf(normalized[0]);
+  const checksum = dataHex.slice(-8);
+  let versionHex = version.toString(16);
+  if (versionHex.length === 1)
+    versionHex = `0${versionHex}`;
+  if (c32checksum(`${versionHex}${dataHex.substring(0, dataHex.length - 8)}`) !== checksum) {
+    throw new Error("Invalid c32check string: checksum mismatch");
+  }
+  return [version, dataHex.substring(0, dataHex.length - 8)];
+}
+function c32address(version, hash160hex) {
+  if (!hash160hex.match(/^[0-9a-fA-F]{40}$/)) {
+    throw new Error("Invalid argument: not a hash160 hex string");
+  }
+  return `S${c32checkEncode(version, hash160hex)}`;
+}
+function c32addressDecode(c32addr) {
+  if (c32addr.length <= 5)
+    throw new Error("Invalid c32 address: invalid length");
+  if (c32addr[0] !== "S")
+    throw new Error('Invalid c32 address: must start with "S"');
+  return c32checkDecode(c32addr.slice(1));
+}
+
+// src/utils/constants.ts
+var MAX_U128 = (1n << 128n) - 1n;
+var MAX_I128 = (1n << 127n) - 1n;
+var MIN_I128 = -(1n << 127n);
+var AddressVersion = {
+  MainnetSingleSig: 22,
+  MainnetMultiSig: 20,
+  TestnetSingleSig: 26,
+  TestnetMultiSig: 21
+};
+var ZERO_ADDRESS = "SP000000000000000000002Q6VF78";
+var TESTNET_ZERO_ADDRESS = "ST000000000000000000002AMW42H";
+var MICROSTX_PER_STX = 1000000n;
+
+// src/utils/hash.ts
+var import_legacy = require("@noble/hashes/legacy.js");
+var import_sha22 = require("@noble/hashes/sha2.js");
+var import_sha23 = require("@noble/hashes/sha2.js");
+function hash160(input) {
+  return import_legacy.ripemd160(import_sha22.sha256(input));
+}
+function txidFromBytes(data) {
+  return bytesToHex(import_sha23.sha512_256(data));
+}
+function hashP2PKH(input) {
+  return bytesToHex(hash160(input));
+}
+
+// src/utils/address.ts
+function publicKeyToAddress(publicKey, network = "mainnet") {
+  const bytes = typeof publicKey === "string" ? hexToBytes(without0x(publicKey)) : publicKey;
+  const version = network === "mainnet" ? AddressVersion.MainnetSingleSig : AddressVersion.TestnetSingleSig;
+  return c32address(version, bytesToHex(hash160(bytes)));
+}
+var CONTRACT_NAME_REGEX = /^[a-zA-Z][a-zA-Z0-9_-]{0,127}$/;
+function validateStacksAddress(address) {
+  try {
+    c32addressDecode(address);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var isValidAddress = validateStacksAddress;
+function parsePrincipal(value) {
+  const parts = value.split(".");
+  if (parts.length > 2)
+    return null;
+  const [address, contractName] = parts;
+  if (!validateStacksAddress(address))
+    return null;
+  if (contractName === undefined)
+    return { address };
+  if (!CONTRACT_NAME_REGEX.test(contractName))
+    return null;
+  return { address, contractName };
+}
+function parseContractId(contractId) {
+  const parsed = parsePrincipal(contractId);
+  if (!parsed?.contractName)
+    throw new Error(`Invalid contract identifier: ${contractId}`);
+  return [parsed.address, parsed.contractName];
+}
+function isClarityName(name) {
+  const regex = /^[a-zA-Z]([a-zA-Z0-9]|[-_!?+<>=/*])*$|^[-+=/*]$|^[<>]=?$/;
+  return regex.test(name) && name.length < 128;
+}
+function isAddressEqual(a, b) {
+  const [versionA, hashA] = c32addressDecode(a);
+  const [versionB, hashB] = c32addressDecode(b);
+  return versionA === versionB && hashA.toLowerCase() === hashB.toLowerCase();
+}
+function addressToVersion(address) {
+  return c32addressDecode(address)[0];
+}
+function getContractAddress(deployer, contractName) {
+  if (!validateStacksAddress(deployer)) {
+    throw new Error(`Invalid deployer address: ${deployer}`);
+  }
+  if (!isClarityName(contractName)) {
+    throw new Error(`Invalid contract name: ${contractName}`);
+  }
+  return `${deployer}.${contractName}`;
+}
+
+// src/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/transaction.ts
+class TransactionError extends BaseError {
+  name = "TransactionError";
+}
+
+class BroadcastError extends BaseError {
+  name = "BroadcastError";
+  txid;
+  reason;
+  reasonData;
+  constructor(message, options) {
+    super(message, options);
+    this.txid = options?.txid;
+    this.reason = options?.reason;
+    this.reasonData = options?.reasonData;
+  }
+}
+
+class TransactionAbortedError extends BaseError {
+  name = "TransactionAbortedError";
+  receipt;
+  constructor(message, options) {
+    super(message, options);
+    this.receipt = options.receipt;
+  }
+}
+
+class TransactionDroppedError extends BaseError {
+  name = "TransactionDroppedError";
+  txid;
+  constructor(message, options) {
+    super(message, options);
+    this.txid = options.txid;
+  }
+}
+
+class WaitForTransactionTimeoutError extends BaseError {
+  name = "WaitForTransactionTimeoutError";
+  txid;
+  constructor(message, options) {
+    super(message, options);
+    this.txid = options.txid;
+  }
+}
+
+class SerializationError extends BaseError {
+  name = "SerializationError";
+}
+
+class SigningError extends BaseError {
+  name = "SigningError";
+}
+
+// src/utils/bytes-reader.ts
+class BytesReader {
+  data;
+  offset = 0;
+  constructor(data) {
+    this.data = data;
+  }
+  remaining() {
+    return this.data.length - this.offset;
+  }
+  ensure(length) {
+    if (this.offset + length > this.data.length) {
+      throw new SerializationError(`Buffer underflow: need ${length} bytes at offset ${this.offset}, have ${this.data.length}`);
+    }
+  }
+  readUInt8() {
+    this.ensure(1);
+    return this.data[this.offset++];
+  }
+  readUInt16BE() {
+    this.ensure(2);
+    const val = (this.data[this.offset] << 8 | this.data[this.offset + 1]) >>> 0;
+    this.offset += 2;
+    return val;
+  }
+  readUInt32BE() {
+    this.ensure(4);
+    const val = (this.data[this.offset] << 24 | this.data[this.offset + 1] << 16 | this.data[this.offset + 2] << 8 | this.data[this.offset + 3]) >>> 0;
+    this.offset += 4;
+    return val;
+  }
+  readBytes(length) {
+    this.ensure(length);
+    const slice = this.data.slice(this.offset, this.offset + length);
+    this.offset += length;
+    return slice;
+  }
+  readBigUInt64BE() {
+    const hex = bytesToHex(this.readBytes(8));
+    return hex.length > 0 ? BigInt(`0x${hex}`) : 0n;
+  }
+}
+
+// src/clarity/deserialize.ts
+function readAddress(reader) {
+  const version = reader.readUInt8();
+  const hash1602 = bytesToHex(reader.readBytes(20));
+  return c32address(version, hash1602);
+}
+function readLPString(reader, prefixBytes = 1) {
+  let length = 0;
+  for (let i = 0;i < prefixBytes; i++) {
+    length = length << 8 | reader.readUInt8();
+  }
+  return bytesToUtf8(reader.readBytes(length));
+}
+var MAX_CV_DEPTH = 64;
+var MIN_LIST_ITEM_BYTES = 1;
+var MIN_TUPLE_ENTRY_BYTES = 2;
+function checkCount(reader, count, minBytes) {
+  if (count * minBytes > reader.remaining()) {
+    throw new SerializationError(`Clarity value declares ${count} elements but only ${reader.remaining()} bytes remain`);
+  }
+}
+function readCV(reader, depth = 0) {
+  if (depth > MAX_CV_DEPTH) {
+    throw new SerializationError(`Clarity value nests deeper than ${MAX_CV_DEPTH} levels`);
+  }
+  const typeByte = reader.readUInt8();
+  const type = clarityTypeFromByte(typeByte);
+  switch (type) {
+    case "int":
+      return intCV(bytesToTwosBigInt(reader.readBytes(16)));
+    case "uint":
+      return uintCV(reader.readBytes(16));
+    case "true":
+      return trueCV();
+    case "false":
+      return falseCV();
+    case "buffer": {
+      const len = reader.readUInt32BE();
+      return bufferCV(reader.readBytes(len));
+    }
+    case "none":
+      return noneCV();
+    case "some":
+      return someCV(readCV(reader, depth + 1));
+    case "ok":
+      return responseOkCV(readCV(reader, depth + 1));
+    case "err":
+      return responseErrorCV(readCV(reader, depth + 1));
+    case "address":
+      return standardPrincipalCV(readAddress(reader));
+    case "contract": {
+      const addr = readAddress(reader);
+      const name = readLPString(reader);
+      return contractPrincipalCV(addr, name);
+    }
+    case "list": {
+      const len = reader.readUInt32BE();
+      checkCount(reader, len, MIN_LIST_ITEM_BYTES);
+      const items = [];
+      for (let i = 0;i < len; i++) {
+        items.push(readCV(reader, depth + 1));
+      }
+      return listCV(items);
+    }
+    case "tuple": {
+      const len = reader.readUInt32BE();
+      checkCount(reader, len, MIN_TUPLE_ENTRY_BYTES);
+      const data = {};
+      for (let i = 0;i < len; i++) {
+        const key = readLPString(reader);
+        data[key] = readCV(reader, depth + 1);
+      }
+      return tupleCV(data);
+    }
+    case "ascii": {
+      const len = reader.readUInt32BE();
+      return stringAsciiCV(bytesToAscii(reader.readBytes(len)));
+    }
+    case "utf8": {
+      const len = reader.readUInt32BE();
+      return stringUtf8CV(bytesToUtf8(reader.readBytes(len)));
+    }
+    default:
+      throw new SerializationError(`Cannot deserialize unknown clarity type: ${type}`);
+  }
+}
+function deserializeCVBytes(input) {
+  const bytes = typeof input === "string" ? hexToBytes(without0x(input)) : input;
+  return readCV(new BytesReader(bytes));
+}
+function deserializeCV(input) {
+  return deserializeCVBytes(input);
+}
+
+// src/clarity/serialize.ts
+var CLARITY_INT_SIZE = 128n;
+var CLARITY_INT_BYTE_SIZE = 16;
+function typeIdByte(type) {
+  return ClarityWireType[type];
+}
+function withTypeId(type, bytes) {
+  return concatBytes(new Uint8Array([typeIdByte(type)]), bytes);
+}
+function serializeAddress(c32Address) {
+  const [version, hash1602] = c32addressDecode(c32Address);
+  return concatBytes(new Uint8Array([version]), hexToBytes(hash1602));
+}
+function serializeLPString(str, prefixBytes = 1) {
+  const content = utf8ToBytes(str);
+  const lengthPrefix = hexToBytes(intToHex(content.byteLength, prefixBytes));
+  return concatBytes(lengthPrefix, content);
+}
+function serializeCVBytes(value) {
+  switch (value.type) {
+    case "true":
+    case "false":
+      return new Uint8Array([typeIdByte(value.type)]);
+    case "int": {
+      const bytes = bigIntToBytes(toTwos(BigInt(value.value), CLARITY_INT_SIZE), CLARITY_INT_BYTE_SIZE);
+      return withTypeId(value.type, bytes);
+    }
+    case "uint": {
+      const bytes = bigIntToBytes(BigInt(value.value), CLARITY_INT_BYTE_SIZE);
+      return withTypeId(value.type, bytes);
+    }
+    case "buffer": {
+      const bufBytes = hexToBytes(value.value);
+      return withTypeId(value.type, concatBytes(writeUInt32BE(bufBytes.length), bufBytes));
+    }
+    case "none":
+      return new Uint8Array([typeIdByte(value.type)]);
+    case "some":
+      return withTypeId(value.type, serializeCVBytes(value.value));
+    case "ok":
+    case "err":
+      return withTypeId(value.type, serializeCVBytes(value.value));
+    case "address":
+      return withTypeId(value.type, serializeAddress(value.value));
+    case "contract": {
+      const [addr, name] = value.value.split(".");
+      if (!addr || !name)
+        throw new Error(`Invalid contract principal: ${value.value}`);
+      return withTypeId(value.type, concatBytes(serializeAddress(addr), serializeLPString(name)));
+    }
+    case "list": {
+      const parts = [writeUInt32BE(value.value.length)];
+      for (const item of value.value) {
+        parts.push(serializeCVBytes(item));
+      }
+      return withTypeId(value.type, concatBytes(...parts));
+    }
+    case "tuple": {
+      const keys = Object.keys(value.value).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+      const parts = [writeUInt32BE(keys.length)];
+      for (const key of keys) {
+        parts.push(serializeLPString(key));
+        parts.push(serializeCVBytes(value.value[key]));
+      }
+      return withTypeId(value.type, concatBytes(...parts));
+    }
+    case "ascii": {
+      const strBytes = asciiToBytes(value.value);
+      return withTypeId(value.type, concatBytes(writeUInt32BE(strBytes.length), strBytes));
+    }
+    case "utf8": {
+      const strBytes = utf8ToBytes(value.value);
+      return withTypeId(value.type, concatBytes(writeUInt32BE(strBytes.length), strBytes));
+    }
+    default:
+      throw new Error("Cannot serialize unknown clarity type");
+  }
+}
+function serializeCV(value) {
+  return bytesToHex(serializeCVBytes(value));
+}
+
+// src/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/structuredData.ts
+var import_sha24 = require("@noble/hashes/sha2.js");
+var SIP018_PREFIX = new Uint8Array([
+  83,
+  73,
+  80,
+  48,
+  49,
+  56
+]);
+function hashStructuredData(structuredData) {
+  return import_sha24.sha256(serializeCVBytes(structuredData));
+}
+function isDomain(value) {
+  if (value.type !== "tuple")
+    return false;
+  const { name, version, "chain-id": chainId } = value.value;
+  return name?.type === "ascii" && version?.type === "ascii" && chainId?.type === "uint";
+}
+function encodeStructuredData(opts) {
+  if (!isDomain(opts.domain)) {
+    throw new Error("domain must be a tuple { name: ascii, version: ascii, chain-id: uint }");
+  }
+  return concatBytes(SIP018_PREFIX, hashStructuredData(opts.domain), hashStructuredData(opts.message));
+}
+function structuredDataHash(opts) {
+  return import_sha24.sha256(encodeStructuredData(opts));
+}
+async function signStructuredData(account, opts) {
+  const vrs = await account.sign(structuredDataHash(opts));
+  if (vrs.length !== 65) {
+    throw new Error(`Expected 65-byte recoverable signature, got ${vrs.length}`);
+  }
+  return bytesToHex(concatBytes(vrs.slice(1), vrs.slice(0, 1)));
+}
+// src/clarity/prettyPrint.ts
+function prettyPrint(val, encoding = "hex") {
+  switch (val.type) {
+    case "true":
+      return "true";
+    case "false":
+      return "false";
+    case "int":
+      return val.value.toString();
+    case "uint":
+      return `u${val.value.toString()}`;
+    case "buffer":
+      if (encoding === "tryAscii") {
+        const str = bytesToAscii(hexToBytes(val.value));
+        if (/^[ -~]*$/.test(str))
+          return JSON.stringify(str);
+      }
+      return `0x${val.value}`;
+    case "none":
+      return "none";
+    case "some":
+      return `(some ${prettyPrint(val.value, encoding)})`;
+    case "ok":
+      return `(ok ${prettyPrint(val.value, encoding)})`;
+    case "err":
+      return `(err ${prettyPrint(val.value, encoding)})`;
+    case "address":
+    case "contract":
+      return val.value;
+    case "list":
+      return `(list ${val.value.map((v) => prettyPrint(v, encoding)).join(" ")})`;
+    case "tuple":
+      return `(tuple ${Object.keys(val.value).map((key) => `(${key} ${prettyPrint(val.value[key], encoding)})`).join(" ")})`;
+    case "ascii":
+      return `"${val.value}"`;
+    case "utf8":
+      return `u"${val.value}"`;
+  }
+}
+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
+      };
+  }
+}
+function cvToValue(val) {
+  switch (val.type) {
+    case "true":
+      return true;
+    case "false":
+      return false;
+    case "int":
+    case "uint":
+      return val.value;
+    case "buffer":
+      return `0x${val.value}`;
+    case "none":
+      return null;
+    case "some":
+      return cvToValue(val.value);
+    case "ok":
+    case "err":
+      return cvToValue(val.value);
+    case "address":
+    case "contract":
+      return val.value;
+    case "list":
+      return val.value.map(cvToValue);
+    case "tuple": {
+      const result = {};
+      for (const key of Object.keys(val.value)) {
+        result[key] = cvToValue(val.value[key]);
+      }
+      return result;
+    }
+    case "ascii":
+    case "utf8":
+      return val.value;
+  }
+}
+function cvToBigInt(val) {
+  if (val.type !== "int" && val.type !== "uint") {
+    throw new Error(`cvToBigInt: expected int or uint, got ${val.type}`);
+  }
+  return val.value;
+}
+function cvToString(val) {
+  if (val.type !== "ascii" && val.type !== "utf8") {
+    throw new Error(`cvToString: expected ascii or utf8, got ${val.type}`);
+  }
+  return val.value;
+}
+function cvToBuffer(val) {
+  if (val.type !== "buffer") {
+    throw new Error(`cvToBuffer: expected buffer, got ${val.type}`);
+  }
+  return val.value;
+}
+function cvToBoolean(val) {
+  if (val.type !== "true" && val.type !== "false") {
+    throw new Error(`cvToBoolean: expected bool, got ${val.type}`);
+  }
+  return val.type === "true";
+}
+function cvToPrincipal(val) {
+  if (val.type !== "address" && val.type !== "contract") {
+    throw new Error(`cvToPrincipal: expected principal or contract, got ${val.type}`);
+  }
+  return val.value;
+}
+// src/clarity/abi/guards.ts
+function isUint128(value) {
+  return typeof value === "bigint" && value >= 0n && value <= MAX_U128;
+}
+function isInt128(value) {
+  return typeof value === "bigint" && value >= MIN_I128 && value <= MAX_I128;
+}
+function isBool(value) {
+  return typeof value === "boolean";
+}
+function isPrincipal(value) {
+  return typeof value === "string" && parsePrincipal(value) !== null;
+}
+function isStandardPrincipal(value) {
+  if (typeof value !== "string")
+    return false;
+  const parsed = parsePrincipal(value);
+  return parsed !== null && parsed.contractName === undefined;
+}
+function isContractPrincipal(value) {
+  if (typeof value !== "string")
+    return false;
+  const parsed = parsePrincipal(value);
+  return parsed !== null && parsed.contractName !== undefined;
+}
+function isTraitReference(value) {
+  return isContractPrincipal(value);
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isUint8Array(value) {
+  return value instanceof Uint8Array;
+}
+function isArray(value, itemGuard) {
+  return Array.isArray(value) && value.every(itemGuard);
+}
+function isOptional(value, guard) {
+  return value === null || guard(value);
+}
+function isOkResponse(response) {
+  return "ok" in response && !("err" in response);
+}
+function isErrResponse(response) {
+  return "err" in response && !("ok" in response);
+}
+function isResponse(value, okGuard, errGuard) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const obj = value;
+  if ("ok" in value && !("err" in value))
+    return okGuard(obj.ok);
+  if ("err" in value && !("ok" in value))
+    return errGuard(obj.err);
+  return false;
+}
+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;
+}
+function isAbiTraitReference(type) {
+  return type === "trait_reference";
+}
+// 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/converters.ts
+class ClarityConversionError extends Error {
+  type;
+  value;
+  constructor(message, type, value) {
+    super(message);
+    this.type = type;
+    this.value = value;
+    this.name = "ClarityConversionError";
+  }
+}
+function jsToClarity(type, value) {
+  if (type === "none")
+    return null;
+  if (type === "uint128") {
+    if (!isUint128(value))
+      throw new ClarityConversionError("Invalid uint128 value", type, value);
+    return value;
+  }
+  if (type === "int128") {
+    if (!isInt128(value))
+      throw new ClarityConversionError("Invalid int128 value", type, value);
+    return value;
+  }
+  if (type === "bool") {
+    if (!isBool(value))
+      throw new ClarityConversionError("Invalid bool value", type, value);
+    return value;
+  }
+  if (type === "principal") {
+    if (!isPrincipal(value))
+      throw new ClarityConversionError("Invalid principal value", type, value);
+    return value;
+  }
+  if (type === "trait_reference") {
+    if (!isPrincipal(value))
+      throw new ClarityConversionError("Invalid trait_reference value", type, value);
+    return value;
+  }
+  if (isAbiStringAscii(type)) {
+    if (!isString(value))
+      throw new ClarityConversionError("Invalid string-ascii value", type, value);
+    const str = value;
+    for (let i = 0;i < str.length; i++) {
+      if (str.charCodeAt(i) > 127) {
+        throw new ClarityConversionError(`Non-ASCII character at position ${i}: '${str[i]}' (code ${str.charCodeAt(i)})`, type, value);
+      }
+    }
+    if (str.length > type["string-ascii"].length) {
+      throw new ClarityConversionError(`String length ${str.length} exceeds max ${type["string-ascii"].length}`, type, value);
+    }
+    return value;
+  }
+  if (isAbiStringUtf8(type)) {
+    if (!isString(value))
+      throw new ClarityConversionError("Invalid string-utf8 value", type, value);
+    const str = value;
+    const byteLength = new TextEncoder().encode(str).length;
+    if (byteLength > type["string-utf8"].length) {
+      throw new ClarityConversionError(`String byte length ${byteLength} exceeds max ${type["string-utf8"].length}`, type, value);
+    }
+    return value;
+  }
+  if (isAbiBuffer(type)) {
+    if (!isUint8Array(value))
+      throw new ClarityConversionError("Invalid buffer value", type, value);
+    const buff = value;
+    if (buff.length > type.buff.length) {
+      throw new ClarityConversionError(`Buffer length ${buff.length} exceeds max ${type.buff.length}`, type, value);
+    }
+    return value;
+  }
+  if (isAbiList(type)) {
+    if (!Array.isArray(value))
+      throw new ClarityConversionError("Expected array for list type", type, value);
+    if (value.length > type.list.length) {
+      throw new ClarityConversionError(`List length ${value.length} exceeds max ${type.list.length}`, type, value);
+    }
+    return value.map((item) => jsToClarity(type.list.type, item));
+  }
+  if (isAbiTuple(type)) {
+    if (typeof value !== "object" || value === null)
+      throw new ClarityConversionError("Expected object for tuple type", type, value);
+    const result = {};
+    for (const field of type.tuple) {
+      const camelKey = toCamelCase(field.name);
+      const hasOriginal = field.name in value;
+      const hasCamel = camelKey in value;
+      if (!hasOriginal && !hasCamel) {
+        throw new ClarityConversionError(`Missing tuple field: ${field.name}`, type, value);
+      }
+      const fieldValue = hasOriginal ? value[field.name] : value[camelKey];
+      result[field.name] = jsToClarity(field.type, fieldValue);
+    }
+    return result;
+  }
+  if (isAbiOptional(type)) {
+    if (value === null || value === undefined)
+      return null;
+    return jsToClarity(type.optional, value);
+  }
+  if (isAbiResponse(type)) {
+    if (typeof value !== "object" || value === null)
+      throw new ClarityConversionError("Expected object for response type", type, value);
+    const hasOk = "ok" in value;
+    const hasErr = "err" in value;
+    if (hasOk && !hasErr) {
+      return {
+        ok: jsToClarity(type.response.ok, value.ok)
+      };
+    }
+    if (hasErr && !hasOk) {
+      return {
+        err: jsToClarity(type.response.error, value.err)
+      };
+    }
+    throw new ClarityConversionError("Response must have exactly 'ok' or 'err' property", type, value);
+  }
+  throw new ClarityConversionError("Unknown Clarity type", type, value);
+}
+function prepareArgs(func, args) {
+  return func.args.map((arg) => {
+    if (!(arg.name in args)) {
+      throw new ClarityConversionError(`Missing argument: ${arg.name}`, arg.type, undefined);
+    }
+    return jsToClarity(arg.type, args[arg.name]);
+  });
+}
+function validateArgs(func, args) {
+  for (const arg of func.args) {
+    if (!(arg.name in args)) {
+      throw new ClarityConversionError(`Missing argument: ${arg.name}`, arg.type, undefined);
+    }
+    jsToClarity(arg.type, args[arg.name]);
+  }
+}
+function validateArgsArray(func, args) {
+  if (args.length !== func.args.length) {
+    throw new ClarityConversionError(`Expected ${func.args.length} arguments, got ${args.length}`, func.args[0]?.type ?? "bool", args);
+  }
+  func.args.forEach((arg, i) => {
+    jsToClarity(arg.type, args[i]);
+  });
+}
+// 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: []
+};
+var sip010Abi = SIP010_ABI;
+var sip009Abi = SIP009_ABI;
+var sip013Abi = SIP013_ABI;
+// src/clarity/abi/classify.ts
+var TRAIT_STANDARDS = ["sip-009", "sip-010", "sip-013"];
+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"
+    ])
+  }
+];
+function indexByName(abi) {
+  const m = new Map;
+  for (const f of abi.functions)
+    m.set(f.name, f);
+  return m;
+}
+function conformsTo(candidate, spec) {
+  const fns = indexByName(candidate);
+  for (const required of spec.abi.functions) {
+    if (spec.optional.has(required.name))
+      continue;
+    const got = fns.get(required.name);
+    if (!got)
+      return false;
+    if (got.access !== required.access)
+      return false;
+    if (got.args.length !== required.args.length)
+      return false;
+  }
+  return true;
+}
+function classifyContract(abi) {
+  if (!abi || !Array.isArray(abi.functions))
+    return [];
+  return STANDARDS.filter((s) => conformsTo(abi, s)).map((s) => s.id);
+}
+function parseDeclaredStandards(claritySource) {
+  const out = new Set;
+  const matches = claritySource.matchAll(/\(impl-trait\s+[^)]+\)/gi);
+  for (const m of matches) {
+    const ref = m[0].toLowerCase();
+    if (ref.includes("sip-010") || ref.includes(".ft-trait"))
+      out.add("sip-010");
+    if (ref.includes("sip-009") || ref.includes("nft-trait"))
+      out.add("sip-009");
+    if (ref.includes("sip-013") || ref.includes("semi-fungible"))
+      out.add("sip-013");
+  }
+  return [...out];
+}
+// src/clarity/abi/normalize.ts
+function normalizeAccess(access) {
+  if (access === "read_only")
+    return "read-only";
+  return access;
+}
+function normalizeType(type) {
+  if (typeof type === "string") {
+    switch (type) {
+      case "uint128":
+      case "int128":
+      case "bool":
+      case "principal":
+      case "trait_reference":
+        return type;
+      default:
+        return type;
+    }
+  }
+  if (typeof type !== "object" || type === null) {
+    throw new Error(`Invalid ABI type: expected object, got ${typeof type}`);
+  }
+  const typeObj = type;
+  if ("buffer" in typeObj) {
+    const buffer = typeObj.buffer;
+    return {
+      buff: {
+        length: buffer?.length ?? 32
+      }
+    };
+  }
+  if ("buff" in typeObj) {
+    const buff = typeObj.buff;
+    return {
+      buff: {
+        length: buff?.length ?? 32
+      }
+    };
+  }
+  if ("string-ascii" in typeObj) {
+    const strAscii = typeObj["string-ascii"];
+    return {
+      "string-ascii": {
+        length: strAscii?.length ?? 256
+      }
+    };
+  }
+  if ("string-utf8" in typeObj) {
+    const strUtf8 = typeObj["string-utf8"];
+    return {
+      "string-utf8": {
+        length: strUtf8?.length ?? 256
+      }
+    };
+  }
+  if ("response" in typeObj) {
+    const response = typeObj.response;
+    return {
+      response: {
+        ok: normalizeType(response?.ok ?? "bool"),
+        error: normalizeType(response?.error ?? "uint128")
+      }
+    };
+  }
+  if ("optional" in typeObj) {
+    return {
+      optional: normalizeType(typeObj.optional)
+    };
+  }
+  if ("list" in typeObj) {
+    const list = typeObj.list;
+    return {
+      list: {
+        type: normalizeType(list?.type ?? "uint128"),
+        length: list?.length ?? 100
+      }
+    };
+  }
+  if ("tuple" in typeObj) {
+    const tuple = typeObj.tuple;
+    return {
+      tuple: tuple.map((field) => ({
+        name: field.name,
+        type: normalizeType(field.type)
+      }))
+    };
+  }
+  throw new Error(`Unknown ABI type structure: ${JSON.stringify(type)}`);
+}
+function normalizeFunction(func) {
+  const access = normalizeAccess(func.access);
+  const args = func.args ?? [];
+  const outputs = func.outputs;
+  return {
+    name: func.name,
+    access,
+    args: args.map((arg) => ({
+      name: arg.name,
+      type: normalizeType(arg.type)
+    })),
+    outputs: normalizeType(typeof outputs === "object" && outputs !== null && "type" in outputs ? outputs.type : outputs)
+  };
+}
+function normalizeMap(map) {
+  return {
+    name: map.name,
+    key: normalizeType(map.key),
+    value: normalizeType(map.value)
+  };
+}
+function normalizeVariable(variable) {
+  return {
+    name: variable.name,
+    type: normalizeType(variable.type),
+    access: variable.access
+  };
+}
+function normalizeFungibleToken(token) {
+  return { name: token.name };
+}
+function normalizeNonFungibleToken(token) {
+  return { name: token.name, type: normalizeType(token.type) };
+}
+function normalizeTraitDefinition(trait) {
+  const rawFunctions = Array.isArray(trait.functions) ? trait.functions : [];
+  const functions = [];
+  for (const func of rawFunctions) {
+    if (typeof func !== "object" || func === null)
+      continue;
+    const normalized = normalizeFunction(func);
+    if (normalized.access === "private")
+      continue;
+    functions.push(normalized);
+  }
+  return { name: trait.name, functions };
+}
+function normalizeAbi(abi) {
+  if (typeof abi !== "object" || abi === null) {
+    return { functions: [] };
+  }
+  const abiObj = abi;
+  const functions = [];
+  const maps = [];
+  const variables = [];
+  const fungibleTokens = [];
+  const nonFungibleTokens = [];
+  const implementedTraits = [];
+  const definedTraits = [];
+  if (Array.isArray(abiObj.functions)) {
+    for (const func of abiObj.functions) {
+      if (typeof func === "object" && func !== null) {
+        functions.push(normalizeFunction(func));
+      }
+    }
+  }
+  if (Array.isArray(abiObj.maps)) {
+    for (const map of abiObj.maps) {
+      if (typeof map === "object" && map !== null) {
+        maps.push(normalizeMap(map));
+      }
+    }
+  }
+  if (Array.isArray(abiObj.variables)) {
+    for (const variable of abiObj.variables) {
+      if (typeof variable === "object" && variable !== null) {
+        variables.push(normalizeVariable(variable));
+      }
+    }
+  }
+  if (Array.isArray(abiObj.fungible_tokens)) {
+    for (const token of abiObj.fungible_tokens) {
+      if (typeof token === "object" && token !== null) {
+        fungibleTokens.push(normalizeFungibleToken(token));
+      }
+    }
+  }
+  if (Array.isArray(abiObj.non_fungible_tokens)) {
+    for (const token of abiObj.non_fungible_tokens) {
+      if (typeof token === "object" && token !== null) {
+        nonFungibleTokens.push(normalizeNonFungibleToken(token));
+      }
+    }
+  }
+  if (Array.isArray(abiObj.implemented_traits)) {
+    for (const trait of abiObj.implemented_traits) {
+      if (typeof trait === "string")
+        implementedTraits.push(trait);
+    }
+  }
+  if (Array.isArray(abiObj.defined_traits)) {
+    for (const trait of abiObj.defined_traits) {
+      if (typeof trait === "object" && trait !== null) {
+        definedTraits.push(normalizeTraitDefinition(trait));
+      }
+    }
+  }
+  return {
+    functions,
+    maps: maps.length > 0 ? maps : undefined,
+    variables: variables.length > 0 ? variables : undefined,
+    fungible_tokens: fungibleTokens.length > 0 ? fungibleTokens : undefined,
+    non_fungible_tokens: nonFungibleTokens.length > 0 ? nonFungibleTokens : undefined,
+    implemented_traits: implementedTraits.length > 0 ? implementedTraits : undefined,
+    defined_traits: definedTraits.length > 0 ? definedTraits : undefined
+  };
+}
+// 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 clarityValueToJS(abiType, cv) {
+  return clarityValueToJSInner(abiType, cv);
+}
+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/postconditions/index.ts
+var exports_postconditions = {};
+__export(exports_postconditions, {
+  wireToPostCondition: () => wireToPostCondition,
+  postConditionToHex: () => postConditionToHex,
+  parsePostConditionAmount: () => parsePostConditionAmount,
+  fromHex: () => fromHex,
+  Pc: () => Pc
+});
+module.exports = __toCommonJS(exports_postconditions);
+
+// src/transactions/types.ts
+var AuthType = {
+  Standard: 4,
+  Sponsored: 5
+};
+var PayloadType = {
+  TokenTransfer: 0,
+  SmartContract: 1,
+  ContractCall: 2,
+  PoisonMicroblock: 3,
+  Coinbase: 4,
+  CoinbaseToAltRecipient: 5,
+  VersionedSmartContract: 6,
+  TenureChange: 7,
+  NakamotoCoinbase: 8
+};
+var ClarityVersion = {
+  Clarity1: 1,
+  Clarity2: 2,
+  Clarity3: 3,
+  Clarity4: 4,
+  Clarity5: 5,
+  Clarity6: 6
+};
+var AnchorMode = {
+  OnChainOnly: 1,
+  OffChainOnly: 2,
+  Any: 3
+};
+var PostConditionModeWire = {
+  Allow: 1,
+  Deny: 2,
+  Originator: 3
+};
+var AddressHashMode = {
+  P2PKH: 0,
+  P2SH: 1,
+  P2WPKH: 2,
+  P2WSH: 3,
+  P2SH_NonSequential: 5,
+  P2WSH_P2SH_NonSequential: 7
+};
+var PubKeyEncoding = {
+  Compressed: 0,
+  Uncompressed: 1
+};
+var FungibleConditionCode = {
+  Equal: 1,
+  Greater: 2,
+  GreaterEqual: 3,
+  Less: 4,
+  LessEqual: 5
+};
+var NonFungibleConditionCode = {
+  Sends: 16,
+  DoesNotSend: 17,
+  MaybeSent: 18
+};
+var PoxConditionCode = {
+  WillNotPerform: 48,
+  MayPerform: 49,
+  WillPerform: 50
+};
+var PostConditionPrincipalId = {
+  Origin: 1,
+  Standard: 2,
+  Contract: 3
+};
+var AssetType = {
+  STX: 0,
+  Fungible: 1,
+  NonFungible: 2,
+  Staking: 3,
+  Pox: 4
+};
+var AuthFieldType = {
+  PublicKeyCompressed: 0,
+  PublicKeyUncompressed: 1,
+  SignatureCompressed: 2,
+  SignatureUncompressed: 3
+};
+var RECOVERABLE_ECDSA_SIG_LENGTH_BYTES = 65;
+var MEMO_MAX_LENGTH_BYTES = 34;
+var MAX_STRING_LENGTH_BYTES = 128;
+var COINBASE_BYTES_LENGTH = 32;
+var VRF_PROOF_BYTES_LENGTH = 80;
+var MICROBLOCK_HEADER_BYTES_LENGTH = 132;
+var TenureChangeCause = {
+  BlockFound: 0,
+  Extended: 1,
+  ExtendedRuntime: 2,
+  ExtendedReadCount: 3,
+  ExtendedReadLength: 4,
+  ExtendedWriteCount: 5,
+  ExtendedWriteLength: 6
+};
+
+// src/transactions/wire/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/transactions/wire/serialize.ts
+function serializeAddress2(c32Address) {
+  const [version, hash1602] = c32addressDecode(c32Address);
+  return concatBytes(new Uint8Array([version]), hexToBytes(hash1602));
+}
+function serializeLPString2(str, prefixBytes = 1) {
+  const content = utf8ToBytes(str);
+  const prefix = hexToBytes(intToHex(content.byteLength, prefixBytes));
+  return concatBytes(prefix, content);
+}
+function serializeLPStringLong(str) {
+  return serializeLPString2(str, 4);
+}
+function serializeMemo(memo) {
+  const content = asciiToBytes(memo);
+  const padded = new Uint8Array(MEMO_MAX_LENGTH_BYTES);
+  padded.set(content.slice(0, MEMO_MAX_LENGTH_BYTES));
+  return padded;
+}
+function serializeSpendingCondition(condition) {
+  const parts = [
+    writeUInt8(condition.hashMode),
+    hexToBytes(condition.signer),
+    intToBytes(condition.nonce, 8),
+    intToBytes(condition.fee, 8)
+  ];
+  if ("signature" in condition) {
+    const sc = condition;
+    parts.push(writeUInt8(sc.keyEncoding));
+    parts.push(hexToBytes(sc.signature));
+  } else {
+    const mc = condition;
+    parts.push(writeUInt32BE(mc.fields.length));
+    for (const field of mc.fields) {
+      parts.push(serializeAuthField(field));
+    }
+    parts.push(writeUInt16BE(mc.signaturesRequired));
+  }
+  return concatBytes(...parts);
+}
+function serializeAuthField(field) {
+  if (field.type === "publicKey") {
+    const typeId2 = field.pubKeyEncoding === 0 ? 0 : 1;
+    return concatBytes(writeUInt8(typeId2), hexToBytes(field.data));
+  }
+  const typeId = field.pubKeyEncoding === 0 ? 2 : 3;
+  return concatBytes(writeUInt8(typeId), hexToBytes(field.data));
+}
+function serializeAuthorization(auth) {
+  const parts = [writeUInt8(auth.authType)];
+  parts.push(serializeSpendingCondition(auth.spendingCondition));
+  if (auth.authType === AuthType.Sponsored) {
+    parts.push(serializeSpendingCondition(auth.sponsorSpendingCondition));
+  }
+  return concatBytes(...parts);
+}
+function serializePrincipal(principal) {
+  switch (principal.type) {
+    case "origin":
+      return writeUInt8(PostConditionPrincipalId.Origin);
+    case "standard":
+      return concatBytes(writeUInt8(PostConditionPrincipalId.Standard), serializeAddress2(principal.address));
+    case "contract":
+      return concatBytes(writeUInt8(PostConditionPrincipalId.Contract), serializeAddress2(principal.address), serializeLPString2(principal.contractName));
+  }
+}
+function serializeAssetInfo(asset) {
+  return concatBytes(serializeAddress2(asset.address), serializeLPString2(asset.contractName), serializeLPString2(asset.assetName));
+}
+function serializePostConditionWire(pc) {
+  const parts = [];
+  switch (pc.type) {
+    case "stx":
+      parts.push(writeUInt8(AssetType.STX));
+      parts.push(serializePrincipal(pc.principal));
+      parts.push(writeUInt8(pc.conditionCode));
+      parts.push(intToBytes(pc.amount, 8));
+      break;
+    case "ft":
+      parts.push(writeUInt8(AssetType.Fungible));
+      parts.push(serializePrincipal(pc.principal));
+      parts.push(serializeAssetInfo(pc.asset));
+      parts.push(writeUInt8(pc.conditionCode));
+      parts.push(intToBytes(pc.amount, 8));
+      break;
+    case "nft":
+      parts.push(writeUInt8(AssetType.NonFungible));
+      parts.push(serializePrincipal(pc.principal));
+      parts.push(serializeAssetInfo(pc.asset));
+      parts.push(serializeCVBytes(pc.assetId));
+      parts.push(writeUInt8(pc.conditionCode));
+      break;
+    case "staking":
+      parts.push(writeUInt8(AssetType.Staking));
+      parts.push(serializePrincipal(pc.principal));
+      parts.push(writeUInt8(pc.conditionCode));
+      parts.push(intToBytes(pc.amount, 8));
+      break;
+    case "pox":
+      parts.push(writeUInt8(AssetType.Pox));
+      parts.push(serializePrincipal(pc.principal));
+      parts.push(writeUInt8(pc.conditionCode));
+      break;
+  }
+  return concatBytes(...parts);
+}
+function serializePostConditions(pcs) {
+  const parts = [writeUInt32BE(pcs.length)];
+  for (const pc of pcs)
+    parts.push(serializePostConditionWire(pc));
+  return concatBytes(...parts);
+}
+function serializePayload(payload) {
+  const parts = [writeUInt8(payload.payloadType)];
+  switch (payload.payloadType) {
+    case PayloadType.TokenTransfer:
+      parts.push(serializeCVBytes(payload.recipient));
+      parts.push(intToBytes(payload.amount, 8));
+      parts.push(serializeMemo(payload.memo));
+      break;
+    case PayloadType.ContractCall:
+      parts.push(serializeAddress2(payload.contractAddress));
+      parts.push(serializeLPString2(payload.contractName));
+      parts.push(serializeLPString2(payload.functionName));
+      parts.push(writeUInt32BE(payload.functionArgs.length));
+      for (const arg of payload.functionArgs) {
+        parts.push(serializeCVBytes(arg));
+      }
+      break;
+    case PayloadType.SmartContract:
+      parts.push(serializeLPString2(payload.contractName));
+      parts.push(serializeLPStringLong(payload.codeBody));
+      break;
+    case PayloadType.VersionedSmartContract:
+      parts.push(writeUInt8(payload.clarityVersion ?? 2));
+      parts.push(serializeLPString2(payload.contractName));
+      parts.push(serializeLPStringLong(payload.codeBody));
+      break;
+    case PayloadType.Coinbase:
+      parts.push(hexToBytes(payload.coinbaseBuffer));
+      break;
+    case PayloadType.CoinbaseToAltRecipient: {
+      const cbAlt = payload;
+      parts.push(hexToBytes(cbAlt.coinbaseBuffer));
+      parts.push(serializeCVBytes(cbAlt.recipient));
+      break;
+    }
+    case PayloadType.PoisonMicroblock: {
+      const pm = payload;
+      parts.push(hexToBytes(pm.header1));
+      parts.push(hexToBytes(pm.header2));
+      break;
+    }
+    case PayloadType.TenureChange: {
+      const tc = payload;
+      parts.push(hexToBytes(tc.tenureConsensusHash));
+      parts.push(hexToBytes(tc.prevTenureConsensusHash));
+      parts.push(hexToBytes(tc.burnViewConsensusHash));
+      parts.push(hexToBytes(tc.previousTenureEnd));
+      parts.push(writeUInt32BE(tc.previousTenureBlocks));
+      parts.push(writeUInt8(tc.cause));
+      parts.push(hexToBytes(tc.pubkeyHash));
+      break;
+    }
+    case PayloadType.NakamotoCoinbase: {
+      const nc = payload;
+      parts.push(hexToBytes(nc.coinbaseBuffer));
+      if (nc.recipient) {
+        parts.push(serializeCVBytes({ type: "some", value: nc.recipient }));
+      } else {
+        parts.push(serializeCVBytes({ type: "none" }));
+      }
+      parts.push(hexToBytes(nc.vrfProof));
+      break;
+    }
+  }
+  return concatBytes(...parts);
+}
+var _txCache = new WeakMap;
+function clearTxCache(tx) {
+  _txCache.delete(tx);
+}
+function serializeTransaction(tx) {
+  const cached = _txCache.get(tx);
+  if (cached)
+    return cached;
+  const bytes = concatBytes(writeUInt8(tx.version), writeUInt32BE(tx.chainId), serializeAuthorization(tx.auth), writeUInt8(tx.anchorMode), writeUInt8(tx.postConditionMode), serializePostConditions(tx.postConditions), serializePayload(tx.payload));
+  _txCache.set(tx, bytes);
+  return bytes;
+}
+function serializeTransactionHex(tx) {
+  return bytesToHex(serializeTransaction(tx));
+}
+
+// src/postconditions/convert.ts
+var MAX_U64 = 18446744073709551615n;
+function parsePostConditionAmount(amount) {
+  const value = intToBigInt(amount);
+  if (value < 0n || value > MAX_U64) {
+    throw new RangeError(`Post-condition amount must be between 0 and ${MAX_U64} (u64 max), received: ${value}`);
+  }
+  return value;
+}
+var FUNGIBLE_CODE_MAP = {
+  eq: FungibleConditionCode.Equal,
+  gt: FungibleConditionCode.Greater,
+  gte: FungibleConditionCode.GreaterEqual,
+  lt: FungibleConditionCode.Less,
+  lte: FungibleConditionCode.LessEqual
+};
+var FUNGIBLE_CODE_REVERSE = {
+  [FungibleConditionCode.Equal]: "eq",
+  [FungibleConditionCode.Greater]: "gt",
+  [FungibleConditionCode.GreaterEqual]: "gte",
+  [FungibleConditionCode.Less]: "lt",
+  [FungibleConditionCode.LessEqual]: "lte"
+};
+var NFT_CODE_MAP = {
+  sent: NonFungibleConditionCode.Sends,
+  "not-sent": NonFungibleConditionCode.DoesNotSend,
+  "maybe-sent": NonFungibleConditionCode.MaybeSent
+};
+var NFT_CODE_REVERSE = {
+  [NonFungibleConditionCode.Sends]: "sent",
+  [NonFungibleConditionCode.DoesNotSend]: "not-sent",
+  [NonFungibleConditionCode.MaybeSent]: "maybe-sent"
+};
+var POX_CODE_MAP = {
+  "will-not-perform": PoxConditionCode.WillNotPerform,
+  "may-perform": PoxConditionCode.MayPerform,
+  "will-perform": PoxConditionCode.WillPerform
+};
+var POX_CODE_REVERSE = {
+  [PoxConditionCode.WillNotPerform]: "will-not-perform",
+  [PoxConditionCode.MayPerform]: "may-perform",
+  [PoxConditionCode.WillPerform]: "will-perform"
+};
+function resolvePrincipal(address) {
+  if (address === "origin")
+    return { type: "origin" };
+  const [addr, name] = address.split(".");
+  if (name) {
+    return { type: "contract", address: addr, contractName: name };
+  }
+  return { type: "standard", address: addr };
+}
+function principalToString(principal) {
+  if (principal.type === "origin")
+    return "origin";
+  if (principal.type === "contract") {
+    return `${principal.address}.${principal.contractName}`;
+  }
+  return principal.address;
+}
+function assetToString(asset) {
+  return `${asset.address}.${asset.contractName}::${asset.assetName}`;
+}
+function parseAsset(asset) {
+  const [contractId, tokenName] = asset.split("::");
+  const [addr, name] = parseContractId(contractId);
+  return { address: addr, contractName: name, assetName: tokenName };
+}
+function convertPostCondition(pc) {
+  switch (pc.type) {
+    case "stx-postcondition":
+      return {
+        type: "stx",
+        principal: resolvePrincipal(pc.address),
+        conditionCode: FUNGIBLE_CODE_MAP[pc.condition],
+        amount: parsePostConditionAmount(pc.amount)
+      };
+    case "ft-postcondition":
+      return {
+        type: "ft",
+        principal: resolvePrincipal(pc.address),
+        asset: parseAsset(pc.asset),
+        conditionCode: FUNGIBLE_CODE_MAP[pc.condition],
+        amount: parsePostConditionAmount(pc.amount)
+      };
+    case "nft-postcondition":
+      return {
+        type: "nft",
+        principal: resolvePrincipal(pc.address),
+        asset: parseAsset(pc.asset),
+        conditionCode: NFT_CODE_MAP[pc.condition],
+        assetId: pc.assetId
+      };
+    case "staking-postcondition":
+      return {
+        type: "staking",
+        principal: resolvePrincipal(pc.address),
+        conditionCode: FUNGIBLE_CODE_MAP[pc.condition],
+        amount: parsePostConditionAmount(pc.amount)
+      };
+    case "pox-postcondition":
+      return {
+        type: "pox",
+        principal: resolvePrincipal(pc.address),
+        conditionCode: POX_CODE_MAP[pc.condition]
+      };
+  }
+}
+function wireToPostCondition(wire) {
+  switch (wire.type) {
+    case "stx":
+      return {
+        type: "stx-postcondition",
+        address: principalToString(wire.principal),
+        condition: fungibleName(wire.conditionCode),
+        amount: wire.amount.toString()
+      };
+    case "ft":
+      return {
+        type: "ft-postcondition",
+        address: principalToString(wire.principal),
+        condition: fungibleName(wire.conditionCode),
+        amount: wire.amount.toString(),
+        asset: assetToString(wire.asset)
+      };
+    case "nft":
+      return {
+        type: "nft-postcondition",
+        address: principalToString(wire.principal),
+        condition: nftName(wire.conditionCode),
+        asset: assetToString(wire.asset),
+        assetId: wire.assetId
+      };
+    case "staking":
+      return {
+        type: "staking-postcondition",
+        address: principalToString(wire.principal),
+        condition: fungibleName(wire.conditionCode),
+        amount: wire.amount.toString()
+      };
+    case "pox":
+      return {
+        type: "pox-postcondition",
+        address: principalToString(wire.principal),
+        condition: poxName(wire.conditionCode)
+      };
+  }
+}
+function fungibleName(code) {
+  const name = FUNGIBLE_CODE_REVERSE[code];
+  if (!name)
+    throw new Error(`Unknown fungible post-condition code: ${code}`);
+  return name;
+}
+function nftName(code) {
+  const name = NFT_CODE_REVERSE[code];
+  if (!name)
+    throw new Error(`Unknown nft post-condition code: ${code}`);
+  return name;
+}
+function poxName(code) {
+  const name = POX_CODE_REVERSE[code];
+  if (!name)
+    throw new Error(`Unknown pox post-condition code: ${code}`);
+  return name;
+}
+function fromHex(hex) {
+  return wireToPostCondition(deserializePostConditionWire(hex));
+}
+function postConditionToHex(pc) {
+  return bytesToHex(serializePostConditionWire(convertPostCondition(pc)));
+}
+
+// src/postconditions/builder.ts
+class PartialPcWithPrincipal {
+  address;
+  constructor(address) {
+    this.address = address;
+  }
+  willSendEq(amount) {
+    return new PartialPcFtWithCode(this.address, amount, "eq");
+  }
+  willSendGte(amount) {
+    return new PartialPcFtWithCode(this.address, amount, "gte");
+  }
+  willSendGt(amount) {
+    return new PartialPcFtWithCode(this.address, amount, "gt");
+  }
+  willSendLte(amount) {
+    return new PartialPcFtWithCode(this.address, amount, "lte");
+  }
+  willSendLt(amount) {
+    return new PartialPcFtWithCode(this.address, amount, "lt");
+  }
+  willSendAsset() {
+    return new PartialPcNftWithCode(this.address, "sent");
+  }
+  willNotSendAsset() {
+    return new PartialPcNftWithCode(this.address, "not-sent");
+  }
+  willMaybeSendAsset() {
+    return new PartialPcNftWithCode(this.address, "maybe-sent");
+  }
+  willPerformPox() {
+    return {
+      type: "pox-postcondition",
+      address: this.address,
+      condition: "will-perform"
+    };
+  }
+  willNotPerformPox() {
+    return {
+      type: "pox-postcondition",
+      address: this.address,
+      condition: "will-not-perform"
+    };
+  }
+  mayPerformPox() {
+    return {
+      type: "pox-postcondition",
+      address: this.address,
+      condition: "may-perform"
+    };
+  }
+}
+
+class PartialPcFtWithCode {
+  address;
+  amount;
+  code;
+  constructor(address, amount, code) {
+    this.address = address;
+    this.amount = amount;
+    this.code = code;
+  }
+  ustx() {
+    return {
+      type: "stx-postcondition",
+      address: this.address,
+      condition: this.code,
+      amount: parsePostConditionAmount(this.amount).toString()
+    };
+  }
+  ustxToLock() {
+    return {
+      type: "staking-postcondition",
+      address: this.address,
+      condition: this.code,
+      amount: parsePostConditionAmount(this.amount).toString()
+    };
+  }
+  ft(contractId, tokenName) {
+    const [address, name] = contractId.split(".");
+    if (!address || !validateStacksAddress(address) || !name) {
+      throw new Error(`Invalid contract id: ${contractId}`);
+    }
+    return {
+      type: "ft-postcondition",
+      address: this.address,
+      condition: this.code,
+      amount: parsePostConditionAmount(this.amount).toString(),
+      asset: `${contractId}::${tokenName}`
+    };
+  }
+}
+
+class PartialPcNftWithCode {
+  address;
+  code;
+  constructor(address, code) {
+    this.address = address;
+    this.code = code;
+  }
+  nft(assetOrContractId, tokenNameOrAssetId, assetId) {
+    let contractAddress;
+    let contractName;
+    let tokenName;
+    let id;
+    if (assetId !== undefined) {
+      [contractAddress, contractName] = parseContractId(assetOrContractId);
+      tokenName = tokenNameOrAssetId;
+      id = assetId;
+    } else {
+      const [principal, tName] = assetOrContractId.split("::");
+      if (!principal || !tName)
+        throw new Error(`Invalid asset name: ${assetOrContractId}`);
+      [contractAddress, contractName] = parseContractId(principal);
+      tokenName = tName;
+      id = tokenNameOrAssetId;
+    }
+    if (!validateStacksAddress(contractAddress)) {
+      throw new Error(`Invalid contract address: ${contractAddress}`);
+    }
+    return {
+      type: "nft-postcondition",
+      address: this.address,
+      condition: this.code,
+      asset: `${contractAddress}.${contractName}::${tokenName}`,
+      assetId: id
+    };
+  }
+}
+var Pc = {
+  principal(address) {
+    const [addr, name] = address.split(".");
+    if (!addr || !validateStacksAddress(addr) || typeof name === "string" && !name) {
+      throw new Error(`Invalid principal: ${address}`);
+    }
+    return new PartialPcWithPrincipal(address);
+  },
+  origin() {
+    return new PartialPcWithPrincipal("origin");
+  },
+  fromHex: (hex) => fromHex(hex)
+};
+// src/bns/index.ts
+var exports_bns = {};
+__export(exports_bns, {
+  validateNamespace: () => validateNamespace,
+  validateName: () => validateName,
+  validateFQN: () => validateFQN,
+  parseFQN: () => parseFQN,
+  hashPreorder: () => hashPreorder,
+  generateSalt: () => generateSalt,
+  formatFQN: () => formatFQN,
+  bns: () => bns,
+  ZONEFILE_RESOLVER_CONTRACTS: () => ZONEFILE_RESOLVER_CONTRACTS,
+  BNS_CONTRACTS: () => BNS_CONTRACTS
+});
+module.exports = __toCommonJS(exports_bns);
+
+// src/transactions/authorization.ts
+var import_hmac = require("@noble/hashes/hmac.js");
+var import_sha25 = require("@noble/hashes/sha2.js");
+var import_secp256k1 = require("@noble/secp256k1");
+import_secp256k1.etc.hmacSha256Sync = (key, ...msgs) => {
+  const h = import_hmac.hmac.create(import_sha25.sha256, key);
+  for (const msg of msgs)
+    h.update(msg);
+  return h.digest();
+};
+var EMPTY_SIG = bytesToHex(new Uint8Array(RECOVERABLE_ECDSA_SIG_LENGTH_BYTES));
+function createSingleSigSpendingCondition(publicKey, nonce, fee) {
+  const pubKeyBytes = hexToBytes(publicKey);
+  const signer = hashP2PKH(pubKeyBytes);
+  const isCompressed = pubKeyBytes.length === 33;
+  return {
+    hashMode: AddressHashMode.P2PKH,
+    signer,
+    nonce,
+    fee,
+    keyEncoding: isCompressed ? PubKeyEncoding.Compressed : PubKeyEncoding.Uncompressed,
+    signature: EMPTY_SIG
+  };
+}
+function createStandardAuth(spendingCondition) {
+  return { authType: AuthType.Standard, spendingCondition };
+}
+function createSponsoredAuth(spendingCondition, sponsorSpendingCondition) {
+  return {
+    authType: AuthType.Sponsored,
+    spendingCondition,
+    sponsorSpendingCondition: sponsorSpendingCondition ?? createSingleSigSpendingCondition("0".repeat(66), 0n, 0n)
+  };
+}
+function clearCondition(condition) {
+  if ("signature" in condition) {
+    return {
+      ...condition,
+      nonce: 0n,
+      fee: 0n,
+      signature: EMPTY_SIG
+    };
+  }
+  return {
+    ...condition,
+    nonce: 0n,
+    fee: 0n,
+    fields: []
+  };
+}
+function sponsorSigningSentinel() {
+  return {
+    hashMode: AddressHashMode.P2PKH,
+    signer: "00".repeat(20),
+    nonce: 0n,
+    fee: 0n,
+    keyEncoding: PubKeyEncoding.Compressed,
+    signature: EMPTY_SIG
+  };
+}
+function intoInitialSighashAuth(auth) {
+  if (auth.authType === AuthType.Standard) {
+    return createStandardAuth(clearCondition(auth.spendingCondition));
+  }
+  return createSponsoredAuth(clearCondition(auth.spendingCondition), sponsorSigningSentinel());
+}
+function sigHashPreSign(curSigHash, authType, fee, nonce) {
+  const data = concatBytes(hexToBytes(curSigHash), new Uint8Array([authType]), intToBytes(fee, 8), intToBytes(nonce, 8));
+  return txidFromBytes(data);
+}
+function sigHashPostSign(curSigHash, pubKeyEncoding, signature) {
+  const data = concatBytes(hexToBytes(curSigHash), new Uint8Array([pubKeyEncoding]), hexToBytes(signature));
+  return txidFromBytes(data);
+}
+function signWithKey(privateKey, messageHash) {
+  const keyBytes = hexToBytes(privateKey).slice(0, 32);
+  const sig = import_secp256k1.sign(messageHash, keyBytes, { lowS: true });
+  const recoveryIdHex = intToHex(sig.recovery, 1);
+  return recoveryIdHex + sig.toCompactHex();
+}
+function nextSignature(curSigHash, authType, fee, nonce, privateKey) {
+  const sigHashPre = sigHashPreSign(curSigHash, authType, fee, nonce);
+  const keyBytes = hexToBytes(privateKey).slice(0, 32);
+  const pubKey = import_secp256k1.getPublicKey(keyBytes, true);
+  const isCompressed = pubKey.length === 33;
+  const pubKeyEncoding = isCompressed ? PubKeyEncoding.Compressed : PubKeyEncoding.Uncompressed;
+  const nextSig = signWithKey(privateKey, sigHashPre);
+  const nextSigHash = sigHashPostSign(sigHashPre, pubKeyEncoding, nextSig);
+  return { nextSig, nextSigHash };
+}
+
+// src/transactions/multisig.ts
+var import_secp256k12 = require("@noble/secp256k1");
+var OP_CHECKMULTISIG = 174;
+function isNonSequential(hashMode) {
+  return (hashMode & 4) !== 0;
+}
+function makeRedeemScript(publicKeys, signaturesRequired) {
+  const parts = [];
+  parts.push(new Uint8Array([80 + signaturesRequired]));
+  for (const pk of publicKeys) {
+    const pkBytes = hexToBytes(pk);
+    parts.push(new Uint8Array([pkBytes.length]));
+    parts.push(pkBytes);
+  }
+  parts.push(new Uint8Array([80 + publicKeys.length]));
+  parts.push(new Uint8Array([OP_CHECKMULTISIG]));
+  return concatBytes(...parts);
+}
+function makeMultiSigAddress(publicKeys, signaturesRequired, chain) {
+  if (signaturesRequired < 1 || signaturesRequired > publicKeys.length) {
+    throw new Error(`signaturesRequired must be between 1 and ${publicKeys.length}`);
+  }
+  const redeemScript = makeRedeemScript(publicKeys, signaturesRequired);
+  const signer = hash160(redeemScript);
+  const version = chain?.addressVersion?.multiSig ?? 20;
+  return c32address(version, bytesToHex(signer));
+}
+function createMultiSigSpendingCondition(publicKeys, signaturesRequired, nonce, fee, hashMode = AddressHashMode.P2SH) {
+  const redeemScript = makeRedeemScript(publicKeys, signaturesRequired);
+  const signer = bytesToHex(hash160(redeemScript));
+  return {
+    hashMode,
+    signer,
+    nonce,
+    fee,
+    fields: [],
+    signaturesRequired
+  };
+}
+function initialSigHash(tx) {
+  const cleared = {
+    ...tx,
+    auth: intoInitialSighashAuth(tx.auth)
+  };
+  return txidFromBytes(serializeTransaction(cleared));
+}
+function nonSequentialPreSignHash(tx) {
+  const condition = tx.auth.spendingCondition;
+  const initHash = initialSigHash(tx);
+  return sigHashPreSign(initHash, AuthType.Standard, condition.fee, condition.nonce);
+}
+function replayMultiSigSigHash(tx) {
+  const condition = tx.auth.spendingCondition;
+  if (isNonSequential(condition.hashMode)) {
+    const preSign = nonSequentialPreSignHash(tx);
+    let curSigHash2 = preSign;
+    for (const field of condition.fields) {
+      curSigHash2 = sigHashPostSign(curSigHash2, field.pubKeyEncoding, field.data);
+    }
+    return curSigHash2;
+  }
+  let curSigHash = initialSigHash(tx);
+  for (const field of condition.fields) {
+    const preSign = sigHashPreSign(curSigHash, AuthType.Standard, condition.fee, condition.nonce);
+    curSigHash = sigHashPostSign(preSign, field.pubKeyEncoding, field.data);
+  }
+  return curSigHash;
+}
+function signMultiSig(tx, privateKey, publicKeys) {
+  const keyBytes = hexToBytes(privateKey).slice(0, 32);
+  const signerPubKey = bytesToHex(import_secp256k12.getPublicKey(keyBytes, true));
+  const signerIndex = publicKeys.findIndex((pk) => pk === signerPubKey);
+  if (signerIndex === -1) {
+    throw new Error("Private key does not correspond to any signer in the multi-sig");
+  }
+  const condition = {
+    ...tx.auth.spendingCondition
+  };
+  if (isNonSequential(condition.hashMode)) {
+    return signNonSequential(tx, condition, privateKey);
+  }
+  return signSequential(tx, condition, privateKey, publicKeys, signerIndex);
+}
+function signNonSequential(tx, condition, privateKey) {
+  const fields = [...condition.fields];
+  const preSignHash = nonSequentialPreSignHash(tx);
+  const keyBytes = hexToBytes(privateKey).slice(0, 32);
+  const sig = import_secp256k12.sign(preSignHash, keyBytes, { lowS: true });
+  const recoveryIdHex = intToHex(sig.recovery, 1);
+  const nextSig = recoveryIdHex + sig.toCompactHex();
+  fields.push({
+    type: "signature",
+    pubKeyEncoding: PubKeyEncoding.Compressed,
+    data: nextSig
+  });
+  const newCondition = { ...condition, fields };
+  const sigCount = fields.filter((f) => f.type === "signature").length;
+  if (sigCount >= condition.signaturesRequired) {
+    return {
+      ...tx,
+      auth: { ...tx.auth, spendingCondition: newCondition }
+    };
+  }
+  return {
+    ...tx,
+    auth: { ...tx.auth, spendingCondition: newCondition }
+  };
+}
+function signSequential(tx, condition, privateKey, publicKeys, signerIndex) {
+  const fields = [...condition.fields];
+  let curSigHash = initialSigHash(tx);
+  for (const field of fields) {
+    const preSign = sigHashPreSign(curSigHash, AuthType.Standard, condition.fee, condition.nonce);
+    curSigHash = sigHashPostSign(preSign, field.pubKeyEncoding, field.data);
+  }
+  for (let i = fields.length;i < signerIndex; i++) {
+    const pubKeyField = {
+      type: "publicKey",
+      pubKeyEncoding: PubKeyEncoding.Compressed,
+      data: publicKeys[i]
+    };
+    fields.push(pubKeyField);
+    const preSign = sigHashPreSign(curSigHash, AuthType.Standard, condition.fee, condition.nonce);
+    curSigHash = sigHashPostSign(preSign, pubKeyField.pubKeyEncoding, pubKeyField.data);
+  }
+  const { nextSig, nextSigHash } = nextSignature(curSigHash, AuthType.Standard, condition.fee, condition.nonce, privateKey);
+  fields.push({
+    type: "signature",
+    pubKeyEncoding: PubKeyEncoding.Compressed,
+    data: nextSig
+  });
+  curSigHash = nextSigHash;
+  const newCondition = { ...condition, fields };
+  const sigCount = fields.filter((f) => f.type === "signature").length;
+  let finalCondition = newCondition;
+  if (sigCount >= condition.signaturesRequired) {
+    finalCondition = finalizeMultiSigCondition(newCondition, publicKeys, curSigHash);
+  }
+  return {
+    ...tx,
+    auth: {
+      ...tx.auth,
+      spendingCondition: finalCondition
+    }
+  };
+}
+async function signMultiSigWithAccount(tx, account, publicKeys) {
+  const signerPubKey = account.publicKey;
+  const signerIndex = publicKeys.findIndex((pk) => pk === signerPubKey);
+  if (signerIndex === -1) {
+    throw new Error("Account does not correspond to any signer in the multi-sig");
+  }
+  const condition = {
+    ...tx.auth.spendingCondition
+  };
+  if (isNonSequential(condition.hashMode)) {
+    return signNonSequentialWithAccount(tx, condition, account);
+  }
+  return signSequentialWithAccount(tx, condition, account, publicKeys, signerIndex);
+}
+async function signNonSequentialWithAccount(tx, condition, account) {
+  const fields = [...condition.fields];
+  const preSignHash = nonSequentialPreSignHash(tx);
+  const sigBytes = await account.sign(hexToBytes(preSignHash));
+  const nextSig = bytesToHex(sigBytes);
+  fields.push({
+    type: "signature",
+    pubKeyEncoding: PubKeyEncoding.Compressed,
+    data: nextSig
+  });
+  const newCondition = { ...condition, fields };
+  return {
+    ...tx,
+    auth: { ...tx.auth, spendingCondition: newCondition }
+  };
+}
+async function signSequentialWithAccount(tx, condition, account, publicKeys, signerIndex) {
+  const fields = [...condition.fields];
+  let curSigHash = initialSigHash(tx);
+  for (const field of fields) {
+    const preSign2 = sigHashPreSign(curSigHash, AuthType.Standard, condition.fee, condition.nonce);
+    curSigHash = sigHashPostSign(preSign2, field.pubKeyEncoding, field.data);
+  }
+  for (let i = fields.length;i < signerIndex; i++) {
+    const pubKeyField = {
+      type: "publicKey",
+      pubKeyEncoding: PubKeyEncoding.Compressed,
+      data: publicKeys[i]
+    };
+    fields.push(pubKeyField);
+    const preSign2 = sigHashPreSign(curSigHash, AuthType.Standard, condition.fee, condition.nonce);
+    curSigHash = sigHashPostSign(preSign2, pubKeyField.pubKeyEncoding, pubKeyField.data);
+  }
+  const preSign = sigHashPreSign(curSigHash, AuthType.Standard, condition.fee, condition.nonce);
+  const sigBytes = await account.sign(hexToBytes(preSign));
+  const nextSig = bytesToHex(sigBytes);
+  const nextSigHash = sigHashPostSign(preSign, PubKeyEncoding.Compressed, nextSig);
+  fields.push({
+    type: "signature",
+    pubKeyEncoding: PubKeyEncoding.Compressed,
+    data: nextSig
+  });
+  curSigHash = nextSigHash;
+  const newCondition = { ...condition, fields };
+  const sigCount = fields.filter((f) => f.type === "signature").length;
+  let finalCondition = newCondition;
+  if (sigCount >= condition.signaturesRequired) {
+    finalCondition = finalizeMultiSigCondition(newCondition, publicKeys, curSigHash);
+  }
+  return {
+    ...tx,
+    auth: {
+      ...tx.auth,
+      spendingCondition: finalCondition
+    }
+  };
+}
+function finalizeMultiSig(tx, publicKeys) {
+  const condition = tx.auth.spendingCondition;
+  if (isNonSequential(condition.hashMode)) {
+    return tx;
+  }
+  const curSigHash = replayMultiSigSigHash(tx);
+  const finalCondition = finalizeMultiSigCondition(condition, publicKeys, curSigHash);
+  return {
+    ...tx,
+    auth: {
+      ...tx.auth,
+      spendingCondition: finalCondition
+    }
+  };
+}
+function finalizeMultiSigCondition(condition, publicKeys, curSigHash) {
+  const fields = [...condition.fields];
+  let sigHash = curSigHash;
+  for (let i = fields.length;i < publicKeys.length; i++) {
+    const pubKeyField = {
+      type: "publicKey",
+      pubKeyEncoding: PubKeyEncoding.Compressed,
+      data: publicKeys[i]
+    };
+    fields.push(pubKeyField);
+    const preSign = sigHashPreSign(sigHash, AuthType.Standard, condition.fee, condition.nonce);
+    sigHash = sigHashPostSign(preSign, pubKeyField.pubKeyEncoding, pubKeyField.data);
+  }
+  return { ...condition, fields };
+}
+function combineMultiSigSignatures(baseTx, signedTxs) {
+  const condition = baseTx.auth.spendingCondition;
+  if (!isNonSequential(condition.hashMode)) {
+    throw new Error("combineMultiSigSignatures only works with non-sequential hash modes (SIP-027)");
+  }
+  const seenSigs = new Set;
+  const signatures = [];
+  for (const stx of signedTxs) {
+    const stxCondition = stx.auth.spendingCondition;
+    for (const field of stxCondition.fields) {
+      if (field.type === "signature" && !seenSigs.has(field.data)) {
+        seenSigs.add(field.data);
+        signatures.push(field);
+      }
+    }
+  }
+  if (signatures.length === 0) {
+    throw new Error("No signatures found in the provided transactions");
+  }
+  const newCondition = {
+    ...condition,
+    fields: signatures
+  };
+  return {
+    ...baseTx,
+    auth: { ...baseTx.auth, spendingCondition: newCondition }
+  };
+}
+
+// src/transactions/build.ts
+function resolvePcMode(mode) {
+  if (mode === "allow")
+    return PostConditionModeWire.Allow;
+  if (mode === "originator")
+    return PostConditionModeWire.Originator;
+  return PostConditionModeWire.Deny;
+}
+function convertPostConditions(pcs) {
+  if (!pcs || pcs.length === 0)
+    return [];
+  return pcs.map((pc) => convertPostCondition(typeof pc === "string" ? fromHex(pc) : pc));
+}
+function resolveSpendingCondition(opts, nonce, fee) {
+  if (opts.publicKeys) {
+    return createMultiSigSpendingCondition(opts.publicKeys, opts.signaturesRequired, nonce, fee, opts.hashMode);
+  }
+  return createSingleSigSpendingCondition(opts.publicKey, nonce, fee);
+}
+function resolveAuth(spendingCondition, sponsored) {
+  return sponsored ? createSponsoredAuth(spendingCondition) : createStandardAuth(spendingCondition);
+}
+function resolveVersionAndChainId(chain) {
+  if (!chain)
+    return { version: 0, chainId: 1 };
+  return { version: chain.transactionVersion, chainId: chain.id };
+}
+function buildTokenTransfer(options) {
+  const { version, chainId } = resolveVersionAndChainId(options.chain);
+  const fee = intToBigInt(options.fee);
+  const nonce = intToBigInt(options.nonce);
+  const spendingCondition = resolveSpendingCondition(options, nonce, fee);
+  const recipient = Cl.principal(options.recipient);
+  const tx = {
+    version,
+    chainId,
+    auth: resolveAuth(spendingCondition, options.sponsored),
+    anchorMode: AnchorMode.Any,
+    postConditionMode: resolvePcMode(options.postConditionMode),
+    postConditions: convertPostConditions(options.postConditions),
+    payload: {
+      payloadType: PayloadType.TokenTransfer,
+      recipient,
+      amount: intToBigInt(options.amount),
+      memo: options.memo ?? ""
+    }
+  };
+  if (options.publicKeys) {
+    tx._multisig = { publicKeys: options.publicKeys };
+  }
+  return tx;
+}
+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;
+}
+function buildContractDeploy(options) {
+  const { version, chainId } = resolveVersionAndChainId(options.chain);
+  const fee = intToBigInt(options.fee);
+  const nonce = intToBigInt(options.nonce);
+  const spendingCondition = resolveSpendingCondition(options, nonce, fee);
+  const clarityVersion = options.clarityVersion ?? ClarityVersion.Clarity4;
+  const tx = {
+    version,
+    chainId,
+    auth: resolveAuth(spendingCondition, options.sponsored),
+    anchorMode: AnchorMode.Any,
+    postConditionMode: resolvePcMode(options.postConditionMode),
+    postConditions: convertPostConditions(options.postConditions),
+    payload: {
+      payloadType: PayloadType.VersionedSmartContract,
+      clarityVersion,
+      contractName: options.contractName,
+      codeBody: options.codeBody
+    }
+  };
+  if (options.publicKeys) {
+    tx._multisig = { publicKeys: options.publicKeys };
+  }
+  return tx;
+}
+
+// src/errors/response.ts
+class MalformedResponseError extends BaseError {
+  name = "MalformedResponseError";
+}
+
+class ReadContractError extends BaseError {
+  name = "ReadContractError";
+}
+
+// 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/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/transactions/signer.ts
+function txid(tx) {
+  return txidFromBytes(serializeTransaction(tx));
+}
+function signBegin(tx) {
+  const cleared = {
+    ...tx,
+    auth: intoInitialSighashAuth(tx.auth)
+  };
+  return txid(cleared);
+}
+function signTransaction(tx, privateKey) {
+  const sigHash = signBegin(tx);
+  const condition = tx.auth.spendingCondition;
+  const { nextSig } = nextSignature(sigHash, AuthType.Standard, condition.fee, condition.nonce, privateKey);
+  return {
+    ...tx,
+    auth: {
+      ...tx.auth,
+      spendingCondition: {
+        ...condition,
+        signature: nextSig
+      }
+    }
+  };
+}
+async function signTransactionWithAccount(tx, account) {
+  const sigHash = signBegin(tx);
+  const condition = tx.auth.spendingCondition;
+  const sigHashPre = sigHashPreSign(sigHash, AuthType.Standard, condition.fee, condition.nonce);
+  const sigBytes = await account.sign(hexToBytes(sigHashPre));
+  const nextSig = bytesToHex(sigBytes);
+  return {
+    ...tx,
+    auth: {
+      ...tx.auth,
+      spendingCondition: {
+        ...condition,
+        signature: nextSig
+      }
+    }
+  };
+}
+function getTransactionId(tx) {
+  return txid(tx);
+}
+function getOriginSigHash(tx) {
+  const condition = tx.auth.spendingCondition;
+  if ("fields" in condition) {
+    return replayMultiSigSigHash(tx);
+  }
+  const initialSigHash2 = signBegin(tx);
+  const sc = condition;
+  const preSign = sigHashPreSign(initialSigHash2, AuthType.Standard, sc.fee, sc.nonce);
+  return sigHashPostSign(preSign, sc.keyEncoding, sc.signature);
+}
+function signSponsor(tx, privateKey) {
+  if (tx.auth.authType !== AuthType.Sponsored) {
+    throw new Error("Transaction must be sponsored");
+  }
+  const auth = tx.auth;
+  const sponsorCondition = auth.sponsorSpendingCondition;
+  const originSigHash = getOriginSigHash(tx);
+  const { nextSig } = nextSignature(originSigHash, AuthType.Sponsored, sponsorCondition.fee, sponsorCondition.nonce, privateKey);
+  return {
+    ...tx,
+    auth: {
+      ...auth,
+      sponsorSpendingCondition: {
+        ...sponsorCondition,
+        signature: nextSig
+      }
+    }
+  };
+}
+async function signSponsorWithAccount(tx, account) {
+  if (tx.auth.authType !== AuthType.Sponsored) {
+    throw new Error("Transaction must be sponsored");
+  }
+  const auth = tx.auth;
+  const sponsorCondition = auth.sponsorSpendingCondition;
+  const originSigHash = getOriginSigHash(tx);
+  const sigHashPre = sigHashPreSign(originSigHash, AuthType.Sponsored, sponsorCondition.fee, sponsorCondition.nonce);
+  const sigBytes = await account.sign(hexToBytes(sigHashPre));
+  const nextSig = bytesToHex(sigBytes);
+  return {
+    ...tx,
+    auth: {
+      ...auth,
+      sponsorSpendingCondition: {
+        ...sponsorCondition,
+        signature: nextSig
+      }
+    }
+  };
+}
+
+// src/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
+class IndexSourceConfigError extends Error {
+  name = "IndexSourceConfigError";
+}
+function isHiroHost(url, client) {
+  let hostname;
+  try {
+    hostname = new URL(url).hostname;
+  } catch {
+    return false;
+  }
+  if (hostname === "hiro.so" || hostname.endsWith(".hiro.so"))
+    return true;
+  const defaults = client.chain?.rpcUrls?.default?.http ?? [];
+  return defaults.some((d) => {
+    try {
+      return new URL(d).hostname === hostname && hostname !== "localhost";
+    } catch {
+      return false;
+    }
+  });
+}
+function indexRequestFn(client, baseUrl, sourceName) {
+  const transportUrl = client.transport.config.url?.replace(/\/$/, "");
+  if (baseUrl === undefined) {
+    if (!transportUrl) {
+      throw new IndexSourceConfigError(`${sourceName} needs the URL of your Secondlayer instance: pass baseUrl, or use an http() transport pointed at the instance`);
+    }
+    if (isHiroHost(transportUrl, client)) {
+      throw new IndexSourceConfigError(`${sourceName} reads /v1/index on a Secondlayer instance, and ${transportUrl} is a Hiro host: pass baseUrl with the URL of your instance`);
+    }
+    return client.request;
+  }
+  const target = baseUrl.replace(/\/$/, "");
+  if (target === transportUrl)
+    return client.request;
+  const { timeout, retryCount, retryDelay } = client.transport.config;
+  return buildRequestFn(target, { timeout, retryCount, retryDelay });
+}
+function indexNotFound(error, sourceName) {
+  if (!(error instanceof HttpRequestError) || error.status !== 404) {
+    return false;
+  }
+  const body = error.details;
+  if (body !== undefined) {
+    try {
+      JSON.parse(body);
+    } catch {
+      throw new IndexSourceConfigError(`${sourceName} got a non-JSON 404 from ${error.url ?? "the transport host"}: it does not serve /v1/index, pass baseUrl with the URL of your Secondlayer instance`, { cause: error });
+    }
+  }
+  return true;
+}
+function normalizeTxid(txid2) {
+  return txid2.startsWith("0x") ? txid2 : `0x${txid2}`;
+}
+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: txid2 }) {
+      let data;
+      try {
+        data = await client.request(`/extended/v1/tx/${encodeURIComponent(normalizeTxid(txid2))}`, { 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(txid2),
+          status,
+          blockHeight: typeof data.block_height === "number" && data.block_height > 0 ? data.block_height : undefined,
+          blockHash: data.block_hash ?? undefined,
+          ...decodeResultHex(data.tx_result?.hex),
+          events: Array.isArray(data.events) ? data.events : [],
+          raw: data
+        }
+      };
+    }
+  };
+}
+function indexTxSource(params = {}) {
+  const headers = params.apiKey ? { authorization: `Bearer ${params.apiKey}` } : undefined;
+  return {
+    canonicalOnly: true,
+    async get({ client, txid: txid2 }) {
+      const request = indexRequestFn(client, params.baseUrl, "indexTxSource");
+      let data;
+      try {
+        data = await request(`/v1/index/transactions/${normalizeTxid(txid2)}`, {
+          method: "GET",
+          headers
+        });
+      } catch (error) {
+        if (indexNotFound(error, "indexTxSource"))
+          return { receipt: null };
+        throw error;
+      }
+      const tx = data.transaction;
+      const tip = data.tip?.block_height;
+      if (!tx)
+        return { receipt: null, tip };
+      const status = normalizeStatus(tx.status) ?? "success";
+      return {
+        receipt: {
+          txid: normalizeTxid(tx.tx_id),
+          status,
+          blockHeight: tx.block_height,
+          ...decodeResultHex(tx.contract_call?.result_hex),
+          events: [],
+          raw: data
+        },
+        tip
+      };
+    }
+  };
+}
+
+// src/actions/public/getTransaction.ts
+async function getTransaction(client, params) {
+  const source = params.source ?? extendedApiSource();
+  const { receipt } = await source.get({ client, txid: params.txid });
+  return receipt;
+}
+
+// src/actions/public/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/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
+function jsonRpcSource() {
+  return {
+    get: ({ client, address }) => getNonce(client, { address })
+  };
+}
+function memoryStore() {
+  const next = new Map;
+  const locks = new Map;
+  function withLock(key, fn) {
+    const prev = locks.get(key) ?? Promise.resolve();
+    const run = prev.then(fn, fn);
+    locks.set(key, run.catch(() => {}));
+    return run;
+  }
+  return {
+    reserve(key, getFloor) {
+      return withLock(key, async () => {
+        let current = next.get(key);
+        if (current === undefined)
+          current = await getFloor();
+        next.set(key, current + 1n);
+        return current;
+      });
+    },
+    reset(key) {
+      next.delete(key);
+    },
+    release(key, nonce) {
+      return withLock(key, async () => {
+        if (next.get(key) === nonce + 1n)
+          next.set(key, nonce);
+      });
+    },
+    peek(key) {
+      return next.get(key);
+    }
+  };
+}
+function nonceKey(client, address) {
+  return `${client.chain?.id ?? "stacks"}:${address}`;
+}
+function createNonceManager(params = {}) {
+  const source = params.source ?? jsonRpcSource();
+  const store = params.store ?? memoryStore();
+  return {
+    consume({ client, address }) {
+      return store.reserve(nonceKey(client, address), () => source.get({ client, address }));
+    },
+    reset({ client, address }) {
+      return store.reset(nonceKey(client, address));
+    },
+    release({ client, address, nonce }) {
+      return store.release?.(nonceKey(client, address), nonce);
+    },
+    async peek({ client, address }) {
+      return store.peek?.(nonceKey(client, address));
+    }
+  };
+}
+async function resolveNonce(client, address) {
+  if (client.nonceManager)
+    return client.nonceManager.consume({ client, address });
+  return getNonce(client, { address });
+}
+async function releaseNonce(client, address, nonce) {
+  if (!client.nonceManager)
+    return;
+  try {
+    await client.nonceManager.release({ client, address, nonce });
+  } catch {}
+}
+async function reconcileNonce(manager, params) {
+  const { client, address, source } = params;
+  const downward = params.downward ?? true;
+  const authoritative = await source.get({ client, address });
+  const tracked = await manager.peek({ client, address });
+  if (tracked === undefined || authoritative === tracked) {
+    return { reset: false, authoritative, tracked };
+  }
+  if (authoritative < tracked && !downward) {
+    return { reset: false, authoritative, tracked };
+  }
+  await manager.reset({ client, address });
+  return { reset: true, authoritative, tracked };
+}
+function startNonceReconciler(manager, params) {
+  const { client, addresses, source, clock } = params;
+  const intervalMs = params.intervalMs ?? 60000;
+  let running = true;
+  const tick = async () => {
+    if (!running)
+      return;
+    for (const address of addresses) {
+      try {
+        const result = await reconcileNonce(manager, {
+          client,
+          address,
+          source,
+          downward: params.downward
+        });
+        params.onReconcile?.(address, result);
+      } catch (error) {
+        try {
+          params.onError?.(address, error);
+        } catch {}
+      }
+    }
+    if (running && clock) {
+      await clock.advance(intervalMs);
+      tick();
+    }
+  };
+  if (clock) {
+    tick();
+    return {
+      stop: () => {
+        running = false;
+      }
+    };
+  }
+  const timer = setInterval(tick, intervalMs);
+  timer.unref?.();
+  return {
+    stop: () => clearInterval(timer)
+  };
+}
+function isNonceConflictError(error) {
+  if (!(error instanceof BroadcastError))
+    return false;
+  if (error.reason === "ConflictingNonceInMempool" || error.reason === "BadNonce") {
+    return true;
+  }
+  if (error.reason !== undefined)
+    return false;
+  return error.message.toLowerCase().includes("nonce");
+}
+async function broadcastWithNonceReset(client, params) {
+  try {
+    const result = await sendTransaction(client, {
+      transaction: params.transaction
+    });
+    return result.txid;
+  } catch (error) {
+    if (client.nonceManager && isNonceConflictError(error)) {
+      await client.nonceManager.reset({ client, address: params.address });
+    }
+    throw error;
+  }
+}
+
+// src/actions/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/wallet/utils.ts
+function isProviderAccount(account) {
+  return account.type === "provider";
+}
+var FEE_TIERS = ["min", "low", "mid", "high"];
+var TIER_INDEX = { low: 0, mid: 1, high: 2 };
+function isFeeTier(fee) {
+  return typeof fee === "string" && FEE_TIERS.includes(fee);
+}
+function minimumFee(transaction) {
+  return BigInt(serializeTransaction(transaction).length);
+}
+function isNoEstimateAvailable(error) {
+  return error instanceof HttpRequestError && error.status === 400 && (error.details?.includes("NoEstimateAvailable") ?? false);
+}
+async function resolveFee(client, transaction, fee) {
+  if (fee !== undefined && !isFeeTier(fee))
+    return { fee: intToBigInt(fee) };
+  const tier = fee ?? "mid";
+  if (tier === "min")
+    return { fee: minimumFee(transaction), tier };
+  let estimates;
+  try {
+    estimates = await estimateFee(client, { transaction });
+  } catch (error) {
+    if (!isNoEstimateAvailable(error))
+      throw error;
+    return { fee: minimumFee(transaction), tier: "min" };
+  }
+  const pick = estimates[TIER_INDEX[tier]] ?? estimates[estimates.length - 1];
+  if (pick)
+    return { fee: BigInt(pick.fee), tier };
+  return { fee: minimumFee(transaction), tier: "min" };
+}
+function setUnsignedFee(transaction, fee) {
+  transaction.auth.spendingCondition.fee = fee;
+  clearTxCache(transaction);
+}
+function assertNoFeeTierForProvider(fee) {
+  if (isFeeTier(fee)) {
+    throw new Error(`Fee tier '${fee}' requires local signing; provider (wallet) accounts set their own fee`);
+  }
+}
+
+// src/actions/wallet/callContract.ts
+async function callContract(client, params) {
+  const account = client.account;
+  if (!account)
+    throw new Error("Account required");
+  const [contractAddress, contractName] = parseContractId(params.contract);
+  if (isProviderAccount(account)) {
+    assertNoFeeTierForProvider(params.fee);
+    const result = await account.provider.request("stx_callContract", {
+      contract: params.contract,
+      functionName: params.functionName,
+      functionArgs: params.functionArgs ?? []
+    });
+    return result.txid;
+  }
+  const managed = params.nonce === undefined && client.nonceManager !== undefined;
+  const nonce = params.nonce ?? await resolveNonce(client, account.address);
+  try {
+    const needsFeeResolution = params.fee === undefined || isFeeTier(params.fee);
+    const unsigned = buildContractCall({
+      contractAddress,
+      contractName,
+      functionName: params.functionName,
+      functionArgs: params.functionArgs ?? [],
+      fee: needsFeeResolution ? 0n : params.fee,
+      nonce,
+      publicKey: account.publicKey,
+      chain: client.chain,
+      postConditionMode: params.postConditionMode,
+      postConditions: params.postConditions
+    });
+    if (needsFeeResolution) {
+      const { fee } = await resolveFee(client, unsigned, params.fee);
+      setUnsignedFee(unsigned, fee);
+    }
+    const signed = await signTransactionWithAccount(unsigned, account);
+    return await broadcastWithNonceReset(client, {
+      transaction: signed,
+      address: account.address
+    });
+  } catch (error) {
+    if (managed)
+      await releaseNonce(client, account.address, nonce);
+    throw error;
+  }
+}
+
+// src/actions/getContract.ts
+function getContract(params) {
+  const { client, address, name: contractName, abi: abi2 } = params;
+  const contractId = `${address}.${contractName}`;
+  const fnByName = new Map;
+  for (const fn of abi2.functions) {
+    fnByName.set(fn.name, fn);
+  }
+  const mapByName = new Map;
+  if (abi2.maps) {
+    for (const m of abi2.maps) {
+      mapByName.set(m.name, m);
+    }
+  }
+  const camelToKebab = new Map;
+  for (const fn of abi2.functions) {
+    camelToKebab.set(toCamelCase(fn.name), fn.name);
+  }
+  if (abi2.maps) {
+    for (const m of abi2.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/bns/abi.ts
 var BNS_ABI = {
@@ -447,13 +4869,13 @@ async function preorder(client, params) {
   const salt = providedSalt ?? generateSalt();
   const hashedSaltedFqn = hashPreorder(name, namespace, salt);
   const bns = getBnsContract(client);
-  const txid = await bns.call.namePreorder({
+  const txid2 = await bns.call.namePreorder({
     hashedSaltedFqn,
     stxToBurn: price
   }, {
     postConditions: client.account?.address ? [Pc.principal(client.account.address).willSendLte(price).ustx()] : []
   });
-  return { txid, salt };
+  return { txid: txid2, salt };
 }
 async function register(client, params) {
   const { name: nameInput, namespace: namespaceInput, salt } = params;
@@ -605,5 +5027,5 @@ function bns() {
   });
 }
 
-//# debugId=9A035D40A860B3C864756E2164756E21
+//# debugId=5D6A745BFFB2148464756E2164756E21
 //# sourceMappingURL=index.cjs.map