@secondlayer/stacks 5.1.3 → 6.1.0

package/dist/src/pox5/index.cjs

@@ -1,3 +1,66 @@
+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/pox5/index.ts
 var exports_pox5 = {};
 __export(exports_pox5, {
@@ -70,6 +133,9 @@ __export(exports_pox5, {
 });
 module.exports = __toCommonJS(exports_pox5);
 
+// src/epochs.ts
+var EPOCH_4_ACTIVATION_BURN_HEIGHT_MAINNET = 960230;
+
 // src/pox5/constants.ts
 var POX5_CONTRACT_NAME = "pox-5";
 var POX5_CONTRACT_ID_MAINNET = `SP000000000000000000002Q6VF78.${POX5_CONTRACT_NAME}`;
@@ -298,21 +364,3337 @@ var POX5_ERROR_DESCRIPTIONS = {
 function parsePox5Error(result) {
   if (result == null)
     return;
-  if (typeof result === "string") {
-    const match = result.trim().match(/^\(err u(\d+)\)$/);
-    return match ? Number(match[1]) : undefined;
+  if (typeof result === "string") {
+    const match = result.trim().match(/^\(err u(\d+)\)$/);
+    return match ? Number(match[1]) : undefined;
+  }
+  if (result.type !== "err")
+    return;
+  return result.value.type === "uint" ? Number(result.value.value) : undefined;
+}
+function describePox5Error(code) {
+  const n = Number(code);
+  const name = POX5_ERROR_NAMES[n];
+  if (!name)
+    return;
+  return { code: n, name, description: POX5_ERROR_DESCRIPTIONS[n] };
+}
+// src/errors/base.ts
+function codeFromName(name) {
+  return name.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").toUpperCase();
+}
+
+class BaseError extends Error {
+  name = "StacksError";
+  #code;
+  shortMessage;
+  details;
+  constructor(shortMessage, options) {
+    const message = [
+      shortMessage,
+      options?.details ? `
+${options.details}` : ""
+    ].join("");
+    super(message, { cause: options?.cause });
+    if (options?.code !== undefined)
+      this.#code = options.code;
+    this.shortMessage = shortMessage;
+    this.details = options?.details;
+  }
+  get code() {
+    return this.#code ?? codeFromName(this.name);
+  }
+  set code(value) {
+    this.#code = value;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      shortMessage: this.shortMessage,
+      details: this.details,
+      cause: this.cause instanceof Error ? this.cause.message : undefined
+    };
+  }
+}
+
+// src/errors/response.ts
+class MalformedResponseError extends BaseError {
+  name = "MalformedResponseError";
+}
+
+class ReadContractError extends BaseError {
+  name = "ReadContractError";
+}
+
+// src/actions/public/getBalance.ts
+async function getBalance(client, params) {
+  const data = await client.request(`/v2/accounts/${encodeURIComponent(params.address)}`, {
+    method: "GET"
+  });
+  const balance = data?.balance;
+  if (typeof balance !== "string" && typeof balance !== "number") {
+    throw new MalformedResponseError(`getBalance: /v2/accounts/${params.address} response is missing "balance"`);
+  }
+  return BigInt(balance);
+}
+
+// src/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/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/bytes-reader.ts
+class BytesReader {
+  data;
+  offset = 0;
+  constructor(data) {
+    this.data = data;
+  }
+  remaining() {
+    return this.data.length - this.offset;
+  }
+  ensure(length) {
+    if (this.offset + length > this.data.length) {
+      throw new SerializationError(`Buffer underflow: need ${length} bytes at offset ${this.offset}, have ${this.data.length}`);
+    }
+  }
+  readUInt8() {
+    this.ensure(1);
+    return this.data[this.offset++];
+  }
+  readUInt16BE() {
+    this.ensure(2);
+    const val = (this.data[this.offset] << 8 | this.data[this.offset + 1]) >>> 0;
+    this.offset += 2;
+    return val;
+  }
+  readUInt32BE() {
+    this.ensure(4);
+    const val = (this.data[this.offset] << 24 | this.data[this.offset + 1] << 16 | this.data[this.offset + 2] << 8 | this.data[this.offset + 3]) >>> 0;
+    this.offset += 4;
+    return val;
+  }
+  readBytes(length) {
+    this.ensure(length);
+    const slice = this.data.slice(this.offset, this.offset + length);
+    this.offset += length;
+    return slice;
+  }
+  readBigUInt64BE() {
+    const hex = bytesToHex(this.readBytes(8));
+    return hex.length > 0 ? BigInt(`0x${hex}`) : 0n;
+  }
+}
+
+// src/utils/c32.ts
+var import_sha2 = require("@noble/hashes/sha2.js");
+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/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/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/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/deserialize.ts
+function readAddress(reader) {
+  const version = reader.readUInt8();
+  const hash1602 = bytesToHex(reader.readBytes(20));
+  return c32address(version, hash1602);
+}
+function readLPString(reader, prefixBytes = 1) {
+  let length = 0;
+  for (let i = 0;i < prefixBytes; i++) {
+    length = length << 8 | reader.readUInt8();
+  }
+  return bytesToUtf8(reader.readBytes(length));
+}
+var MAX_CV_DEPTH = 64;
+var MIN_LIST_ITEM_BYTES = 1;
+var MIN_TUPLE_ENTRY_BYTES = 2;
+function checkCount(reader, count, minBytes) {
+  if (count * minBytes > reader.remaining()) {
+    throw new SerializationError(`Clarity value declares ${count} elements but only ${reader.remaining()} bytes remain`);
+  }
+}
+function readCV(reader, depth = 0) {
+  if (depth > MAX_CV_DEPTH) {
+    throw new SerializationError(`Clarity value nests deeper than ${MAX_CV_DEPTH} levels`);
+  }
+  const typeByte = reader.readUInt8();
+  const type = clarityTypeFromByte(typeByte);
+  switch (type) {
+    case "int":
+      return intCV(bytesToTwosBigInt(reader.readBytes(16)));
+    case "uint":
+      return uintCV(reader.readBytes(16));
+    case "true":
+      return trueCV();
+    case "false":
+      return falseCV();
+    case "buffer": {
+      const len = reader.readUInt32BE();
+      return bufferCV(reader.readBytes(len));
+    }
+    case "none":
+      return noneCV();
+    case "some":
+      return someCV(readCV(reader, depth + 1));
+    case "ok":
+      return responseOkCV(readCV(reader, depth + 1));
+    case "err":
+      return responseErrorCV(readCV(reader, depth + 1));
+    case "address":
+      return standardPrincipalCV(readAddress(reader));
+    case "contract": {
+      const addr = readAddress(reader);
+      const name = readLPString(reader);
+      return contractPrincipalCV(addr, name);
+    }
+    case "list": {
+      const len = reader.readUInt32BE();
+      checkCount(reader, len, MIN_LIST_ITEM_BYTES);
+      const items = [];
+      for (let i = 0;i < len; i++) {
+        items.push(readCV(reader, depth + 1));
+      }
+      return listCV(items);
+    }
+    case "tuple": {
+      const len = reader.readUInt32BE();
+      checkCount(reader, len, MIN_TUPLE_ENTRY_BYTES);
+      const data = {};
+      for (let i = 0;i < len; i++) {
+        const key = readLPString(reader);
+        data[key] = readCV(reader, depth + 1);
+      }
+      return tupleCV(data);
+    }
+    case "ascii": {
+      const len = reader.readUInt32BE();
+      return stringAsciiCV(bytesToAscii(reader.readBytes(len)));
+    }
+    case "utf8": {
+      const len = reader.readUInt32BE();
+      return stringUtf8CV(bytesToUtf8(reader.readBytes(len)));
+    }
+    default:
+      throw new SerializationError(`Cannot deserialize unknown clarity type: ${type}`);
+  }
+}
+function deserializeCVBytes(input) {
+  const bytes = typeof input === "string" ? hexToBytes(without0x(input)) : input;
+  return readCV(new BytesReader(bytes));
+}
+function deserializeCV(input) {
+  return deserializeCVBytes(input);
+}
+
+// src/actions/public/getDataVar.ts
+async function getDataVar(client, params) {
+  const [address, name] = parseContractId(params.contract);
+  const path = `/v2/data_var/${address}/${name}/${params.varName}?proof=0`;
+  const data = await client.request(path, { method: "GET" });
+  if (typeof data?.data !== "string") {
+    throw new MalformedResponseError(`getDataVar: /v2/data_var/${address}/${name}/${params.varName} response is missing "data"`);
+  }
+  return deserializeCVBytes(data.data);
+}
+
+// src/actions/public/getMapEntry.ts
+async function getMapEntry(client, params) {
+  const [address, name] = parseContractId(params.contract);
+  const serializedKey = with0x(bytesToHex(serializeCVBytes(params.key)));
+  const data = await client.request(`/v2/map_entry/${address}/${name}/${params.mapName}`, {
+    method: "POST",
+    body: serializedKey
+  });
+  if (typeof data?.data !== "string") {
+    throw new MalformedResponseError(`getMapEntry: /v2/map_entry/${address}/${name}/${params.mapName} response is missing "data"`);
+  }
+  return deserializeCVBytes(data.data);
+}
+
+// src/clarity/abi/utils.ts
+function toCamelCase(str) {
+  return str.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase()).replace(/-([A-Z])/g, (_, letter) => letter).replace(/-(\d)/g, (_, digit) => digit).replace(/-/g, "").replace(/^\d/, "_$&");
+}
+// src/clarity/abi/guards.ts
+function 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/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/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/transactions/authorization.ts
+var import_hmac = require("@noble/hashes/hmac.js");
+var import_sha24 = require("@noble/hashes/sha2.js");
+var import_secp256k1 = require("@noble/secp256k1");
+import_secp256k1.etc.hmacSha256Sync = (key, ...msgs) => {
+  const h = import_hmac.hmac.create(import_sha24.sha256, key);
+  for (const msg of msgs)
+    h.update(msg);
+  return h.digest();
+};
+var EMPTY_SIG = bytesToHex(new Uint8Array(RECOVERABLE_ECDSA_SIG_LENGTH_BYTES));
+function createSingleSigSpendingCondition(publicKey, nonce, fee) {
+  const pubKeyBytes = hexToBytes(publicKey);
+  const signer = hashP2PKH(pubKeyBytes);
+  const isCompressed = pubKeyBytes.length === 33;
+  return {
+    hashMode: AddressHashMode.P2PKH,
+    signer,
+    nonce,
+    fee,
+    keyEncoding: isCompressed ? PubKeyEncoding.Compressed : PubKeyEncoding.Uncompressed,
+    signature: EMPTY_SIG
+  };
+}
+function createStandardAuth(spendingCondition) {
+  return { authType: AuthType.Standard, spendingCondition };
+}
+function createSponsoredAuth(spendingCondition, sponsorSpendingCondition) {
+  return {
+    authType: AuthType.Sponsored,
+    spendingCondition,
+    sponsorSpendingCondition: sponsorSpendingCondition ?? createSingleSigSpendingCondition("0".repeat(66), 0n, 0n)
+  };
+}
+function clearCondition(condition) {
+  if ("signature" in condition) {
+    return {
+      ...condition,
+      nonce: 0n,
+      fee: 0n,
+      signature: EMPTY_SIG
+    };
+  }
+  return {
+    ...condition,
+    nonce: 0n,
+    fee: 0n,
+    fields: []
+  };
+}
+function sponsorSigningSentinel() {
+  return {
+    hashMode: AddressHashMode.P2PKH,
+    signer: "00".repeat(20),
+    nonce: 0n,
+    fee: 0n,
+    keyEncoding: PubKeyEncoding.Compressed,
+    signature: EMPTY_SIG
+  };
+}
+function intoInitialSighashAuth(auth) {
+  if (auth.authType === AuthType.Standard) {
+    return createStandardAuth(clearCondition(auth.spendingCondition));
+  }
+  return createSponsoredAuth(clearCondition(auth.spendingCondition), sponsorSigningSentinel());
+}
+function sigHashPreSign(curSigHash, authType, fee, nonce) {
+  const data = concatBytes(hexToBytes(curSigHash), new Uint8Array([authType]), intToBytes(fee, 8), intToBytes(nonce, 8));
+  return txidFromBytes(data);
+}
+function sigHashPostSign(curSigHash, pubKeyEncoding, signature) {
+  const data = concatBytes(hexToBytes(curSigHash), new Uint8Array([pubKeyEncoding]), hexToBytes(signature));
+  return txidFromBytes(data);
+}
+function signWithKey(privateKey, messageHash) {
+  const keyBytes = hexToBytes(privateKey).slice(0, 32);
+  const sig = import_secp256k1.sign(messageHash, keyBytes, { lowS: true });
+  const recoveryIdHex = intToHex(sig.recovery, 1);
+  return recoveryIdHex + sig.toCompactHex();
+}
+function nextSignature(curSigHash, authType, fee, nonce, privateKey) {
+  const sigHashPre = sigHashPreSign(curSigHash, authType, fee, nonce);
+  const keyBytes = hexToBytes(privateKey).slice(0, 32);
+  const pubKey = import_secp256k1.getPublicKey(keyBytes, true);
+  const isCompressed = pubKey.length === 33;
+  const pubKeyEncoding = isCompressed ? PubKeyEncoding.Compressed : PubKeyEncoding.Uncompressed;
+  const nextSig = signWithKey(privateKey, sigHashPre);
+  const nextSigHash = sigHashPostSign(sigHashPre, pubKeyEncoding, nextSig);
+  return { nextSig, nextSigHash };
+}
+
+// src/transactions/multisig.ts
+var import_secp256k12 = require("@noble/secp256k1");
+var OP_CHECKMULTISIG = 174;
+function isNonSequential(hashMode) {
+  return (hashMode & 4) !== 0;
+}
+function makeRedeemScript(publicKeys, signaturesRequired) {
+  const parts = [];
+  parts.push(new Uint8Array([80 + signaturesRequired]));
+  for (const pk of publicKeys) {
+    const pkBytes = hexToBytes(pk);
+    parts.push(new Uint8Array([pkBytes.length]));
+    parts.push(pkBytes);
+  }
+  parts.push(new Uint8Array([80 + publicKeys.length]));
+  parts.push(new Uint8Array([OP_CHECKMULTISIG]));
+  return concatBytes(...parts);
+}
+function makeMultiSigAddress(publicKeys, signaturesRequired, chain) {
+  if (signaturesRequired < 1 || signaturesRequired > publicKeys.length) {
+    throw new Error(`signaturesRequired must be between 1 and ${publicKeys.length}`);
+  }
+  const redeemScript = makeRedeemScript(publicKeys, signaturesRequired);
+  const signer = hash160(redeemScript);
+  const version = chain?.addressVersion?.multiSig ?? 20;
+  return c32address(version, bytesToHex(signer));
+}
+function createMultiSigSpendingCondition(publicKeys, signaturesRequired, nonce, fee, hashMode = AddressHashMode.P2SH) {
+  const redeemScript = makeRedeemScript(publicKeys, signaturesRequired);
+  const signer = bytesToHex(hash160(redeemScript));
+  return {
+    hashMode,
+    signer,
+    nonce,
+    fee,
+    fields: [],
+    signaturesRequired
+  };
+}
+function initialSigHash(tx) {
+  const cleared = {
+    ...tx,
+    auth: intoInitialSighashAuth(tx.auth)
+  };
+  return txidFromBytes(serializeTransaction(cleared));
+}
+function nonSequentialPreSignHash(tx) {
+  const condition = tx.auth.spendingCondition;
+  const initHash = initialSigHash(tx);
+  return sigHashPreSign(initHash, AuthType.Standard, condition.fee, condition.nonce);
+}
+function replayMultiSigSigHash(tx) {
+  const condition = tx.auth.spendingCondition;
+  if (isNonSequential(condition.hashMode)) {
+    const preSign = nonSequentialPreSignHash(tx);
+    let curSigHash2 = preSign;
+    for (const field of condition.fields) {
+      curSigHash2 = sigHashPostSign(curSigHash2, field.pubKeyEncoding, field.data);
+    }
+    return curSigHash2;
+  }
+  let curSigHash = initialSigHash(tx);
+  for (const field of condition.fields) {
+    const preSign = sigHashPreSign(curSigHash, AuthType.Standard, condition.fee, condition.nonce);
+    curSigHash = sigHashPostSign(preSign, field.pubKeyEncoding, field.data);
+  }
+  return curSigHash;
+}
+function signMultiSig(tx, privateKey, publicKeys) {
+  const keyBytes = hexToBytes(privateKey).slice(0, 32);
+  const signerPubKey = bytesToHex(import_secp256k12.getPublicKey(keyBytes, true));
+  const signerIndex = publicKeys.findIndex((pk) => pk === signerPubKey);
+  if (signerIndex === -1) {
+    throw new Error("Private key does not correspond to any signer in the multi-sig");
+  }
+  const condition = {
+    ...tx.auth.spendingCondition
+  };
+  if (isNonSequential(condition.hashMode)) {
+    return signNonSequential(tx, condition, privateKey);
+  }
+  return signSequential(tx, condition, privateKey, publicKeys, signerIndex);
+}
+function signNonSequential(tx, condition, privateKey) {
+  const fields = [...condition.fields];
+  const preSignHash = nonSequentialPreSignHash(tx);
+  const keyBytes = hexToBytes(privateKey).slice(0, 32);
+  const sig = import_secp256k12.sign(preSignHash, keyBytes, { lowS: true });
+  const recoveryIdHex = intToHex(sig.recovery, 1);
+  const nextSig = recoveryIdHex + sig.toCompactHex();
+  fields.push({
+    type: "signature",
+    pubKeyEncoding: PubKeyEncoding.Compressed,
+    data: nextSig
+  });
+  const newCondition = { ...condition, fields };
+  const sigCount = fields.filter((f) => f.type === "signature").length;
+  if (sigCount >= condition.signaturesRequired) {
+    return {
+      ...tx,
+      auth: { ...tx.auth, spendingCondition: newCondition }
+    };
+  }
+  return {
+    ...tx,
+    auth: { ...tx.auth, spendingCondition: newCondition }
+  };
+}
+function signSequential(tx, condition, privateKey, publicKeys, signerIndex) {
+  const fields = [...condition.fields];
+  let curSigHash = initialSigHash(tx);
+  for (const field of fields) {
+    const preSign = sigHashPreSign(curSigHash, AuthType.Standard, condition.fee, condition.nonce);
+    curSigHash = sigHashPostSign(preSign, field.pubKeyEncoding, field.data);
+  }
+  for (let i = fields.length;i < signerIndex; i++) {
+    const pubKeyField = {
+      type: "publicKey",
+      pubKeyEncoding: PubKeyEncoding.Compressed,
+      data: publicKeys[i]
+    };
+    fields.push(pubKeyField);
+    const preSign = sigHashPreSign(curSigHash, AuthType.Standard, condition.fee, condition.nonce);
+    curSigHash = sigHashPostSign(preSign, pubKeyField.pubKeyEncoding, pubKeyField.data);
+  }
+  const { nextSig, nextSigHash } = nextSignature(curSigHash, AuthType.Standard, condition.fee, condition.nonce, privateKey);
+  fields.push({
+    type: "signature",
+    pubKeyEncoding: PubKeyEncoding.Compressed,
+    data: nextSig
+  });
+  curSigHash = nextSigHash;
+  const newCondition = { ...condition, fields };
+  const sigCount = fields.filter((f) => f.type === "signature").length;
+  let finalCondition = newCondition;
+  if (sigCount >= condition.signaturesRequired) {
+    finalCondition = finalizeMultiSigCondition(newCondition, publicKeys, curSigHash);
+  }
+  return {
+    ...tx,
+    auth: {
+      ...tx.auth,
+      spendingCondition: finalCondition
+    }
+  };
+}
+async function signMultiSigWithAccount(tx, account, publicKeys) {
+  const signerPubKey = account.publicKey;
+  const signerIndex = publicKeys.findIndex((pk) => pk === signerPubKey);
+  if (signerIndex === -1) {
+    throw new Error("Account does not correspond to any signer in the multi-sig");
+  }
+  const condition = {
+    ...tx.auth.spendingCondition
+  };
+  if (isNonSequential(condition.hashMode)) {
+    return signNonSequentialWithAccount(tx, condition, account);
+  }
+  return signSequentialWithAccount(tx, condition, account, publicKeys, signerIndex);
+}
+async function signNonSequentialWithAccount(tx, condition, account) {
+  const fields = [...condition.fields];
+  const preSignHash = nonSequentialPreSignHash(tx);
+  const sigBytes = await account.sign(hexToBytes(preSignHash));
+  const nextSig = bytesToHex(sigBytes);
+  fields.push({
+    type: "signature",
+    pubKeyEncoding: PubKeyEncoding.Compressed,
+    data: nextSig
+  });
+  const newCondition = { ...condition, fields };
+  return {
+    ...tx,
+    auth: { ...tx.auth, spendingCondition: newCondition }
+  };
+}
+async function signSequentialWithAccount(tx, condition, account, publicKeys, signerIndex) {
+  const fields = [...condition.fields];
+  let curSigHash = initialSigHash(tx);
+  for (const field of fields) {
+    const preSign2 = sigHashPreSign(curSigHash, AuthType.Standard, condition.fee, condition.nonce);
+    curSigHash = sigHashPostSign(preSign2, field.pubKeyEncoding, field.data);
+  }
+  for (let i = fields.length;i < signerIndex; i++) {
+    const pubKeyField = {
+      type: "publicKey",
+      pubKeyEncoding: PubKeyEncoding.Compressed,
+      data: publicKeys[i]
+    };
+    fields.push(pubKeyField);
+    const preSign2 = sigHashPreSign(curSigHash, AuthType.Standard, condition.fee, condition.nonce);
+    curSigHash = sigHashPostSign(preSign2, pubKeyField.pubKeyEncoding, pubKeyField.data);
+  }
+  const preSign = sigHashPreSign(curSigHash, AuthType.Standard, condition.fee, condition.nonce);
+  const sigBytes = await account.sign(hexToBytes(preSign));
+  const nextSig = bytesToHex(sigBytes);
+  const nextSigHash = sigHashPostSign(preSign, PubKeyEncoding.Compressed, nextSig);
+  fields.push({
+    type: "signature",
+    pubKeyEncoding: PubKeyEncoding.Compressed,
+    data: nextSig
+  });
+  curSigHash = nextSigHash;
+  const newCondition = { ...condition, fields };
+  const sigCount = fields.filter((f) => f.type === "signature").length;
+  let finalCondition = newCondition;
+  if (sigCount >= condition.signaturesRequired) {
+    finalCondition = finalizeMultiSigCondition(newCondition, publicKeys, curSigHash);
+  }
+  return {
+    ...tx,
+    auth: {
+      ...tx.auth,
+      spendingCondition: finalCondition
+    }
+  };
+}
+function finalizeMultiSig(tx, publicKeys) {
+  const condition = tx.auth.spendingCondition;
+  if (isNonSequential(condition.hashMode)) {
+    return tx;
+  }
+  const curSigHash = replayMultiSigSigHash(tx);
+  const finalCondition = finalizeMultiSigCondition(condition, publicKeys, curSigHash);
+  return {
+    ...tx,
+    auth: {
+      ...tx.auth,
+      spendingCondition: finalCondition
+    }
+  };
+}
+function finalizeMultiSigCondition(condition, publicKeys, curSigHash) {
+  const fields = [...condition.fields];
+  let sigHash = curSigHash;
+  for (let i = fields.length;i < publicKeys.length; i++) {
+    const pubKeyField = {
+      type: "publicKey",
+      pubKeyEncoding: PubKeyEncoding.Compressed,
+      data: publicKeys[i]
+    };
+    fields.push(pubKeyField);
+    const preSign = sigHashPreSign(sigHash, AuthType.Standard, condition.fee, condition.nonce);
+    sigHash = sigHashPostSign(preSign, pubKeyField.pubKeyEncoding, pubKeyField.data);
+  }
+  return { ...condition, fields };
+}
+function combineMultiSigSignatures(baseTx, signedTxs) {
+  const condition = baseTx.auth.spendingCondition;
+  if (!isNonSequential(condition.hashMode)) {
+    throw new Error("combineMultiSigSignatures only works with non-sequential hash modes (SIP-027)");
+  }
+  const seenSigs = new Set;
+  const signatures = [];
+  for (const stx of signedTxs) {
+    const stxCondition = stx.auth.spendingCondition;
+    for (const field of stxCondition.fields) {
+      if (field.type === "signature" && !seenSigs.has(field.data)) {
+        seenSigs.add(field.data);
+        signatures.push(field);
+      }
+    }
+  }
+  if (signatures.length === 0) {
+    throw new Error("No signatures found in the provided transactions");
+  }
+  const newCondition = {
+    ...condition,
+    fields: signatures
+  };
+  return {
+    ...baseTx,
+    auth: { ...baseTx.auth, spendingCondition: newCondition }
+  };
+}
+
+// src/transactions/build.ts
+function resolvePcMode(mode) {
+  if (mode === "allow")
+    return PostConditionModeWire.Allow;
+  if (mode === "originator")
+    return PostConditionModeWire.Originator;
+  return PostConditionModeWire.Deny;
+}
+function convertPostConditions(pcs) {
+  if (!pcs || pcs.length === 0)
+    return [];
+  return pcs.map((pc) => convertPostCondition(typeof pc === "string" ? fromHex(pc) : pc));
+}
+function resolveSpendingCondition(opts, nonce, fee) {
+  if (opts.publicKeys) {
+    return createMultiSigSpendingCondition(opts.publicKeys, opts.signaturesRequired, nonce, fee, opts.hashMode);
+  }
+  return createSingleSigSpendingCondition(opts.publicKey, nonce, fee);
+}
+function resolveAuth(spendingCondition, sponsored) {
+  return sponsored ? createSponsoredAuth(spendingCondition) : createStandardAuth(spendingCondition);
+}
+function resolveVersionAndChainId(chain) {
+  if (!chain)
+    return { version: 0, chainId: 1 };
+  return { version: chain.transactionVersion, chainId: chain.id };
+}
+function buildTokenTransfer(options) {
+  const { version, chainId } = resolveVersionAndChainId(options.chain);
+  const fee = intToBigInt(options.fee);
+  const nonce = intToBigInt(options.nonce);
+  const spendingCondition = resolveSpendingCondition(options, nonce, fee);
+  const recipient = Cl.principal(options.recipient);
+  const tx = {
+    version,
+    chainId,
+    auth: resolveAuth(spendingCondition, options.sponsored),
+    anchorMode: AnchorMode.Any,
+    postConditionMode: resolvePcMode(options.postConditionMode),
+    postConditions: convertPostConditions(options.postConditions),
+    payload: {
+      payloadType: PayloadType.TokenTransfer,
+      recipient,
+      amount: intToBigInt(options.amount),
+      memo: options.memo ?? ""
+    }
+  };
+  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/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 (result.type !== "err")
-    return;
-  return result.value.type === "uint" ? Number(result.value.value) : undefined;
+  if (authoritative < tracked && !downward) {
+    return { reset: false, authoritative, tracked };
+  }
+  await manager.reset({ client, address });
+  return { reset: true, authoritative, tracked };
 }
-function describePox5Error(code) {
-  const n = Number(code);
-  const name = POX5_ERROR_NAMES[n];
-  if (!name)
-    return;
-  return { code: n, name, description: POX5_ERROR_DESCRIPTIONS[n] };
+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 } = params;
+  const contractId = `${address}.${contractName}`;
+  const fnByName = new Map;
+  for (const fn of abi.functions) {
+    fnByName.set(fn.name, fn);
+  }
+  const mapByName = new Map;
+  if (abi.maps) {
+    for (const m of abi.maps) {
+      mapByName.set(m.name, m);
+    }
+  }
+  const camelToKebab = new Map;
+  for (const fn of abi.functions) {
+    camelToKebab.set(toCamelCase(fn.name), fn.name);
+  }
+  if (abi.maps) {
+    for (const m of abi.maps) {
+      camelToKebab.set(toCamelCase(m.name), m.name);
+    }
+  }
+  const read = new Proxy({}, {
+    get(_target, prop) {
+      const fnName = camelToKebab.get(prop) ?? prop;
+      const fn = fnByName.get(fnName);
+      if (!fn || fn.access !== "read-only")
+        return;
+      return async (args = {}) => {
+        const clarityArgs = buildFunctionArgs(fn, args);
+        const result = await readContract(client, {
+          contract: contractId,
+          functionName: fn.name,
+          args: clarityArgs
+        });
+        const jsValue = clarityValueToJSUntyped(fn.outputs, result);
+        if (isResponseOutput(fn.outputs)) {
+          const resp = jsValue;
+          if ("ok" in resp)
+            return resp.ok;
+          throw new ContractResponseError(`${contractId}::${fn.name} returned (err ${formatErrValue(resp.err)})`, resp.err);
+        }
+        return jsValue;
+      };
+    }
+  });
+  const call = new Proxy({}, {
+    get(_target, prop) {
+      const fnName = camelToKebab.get(prop) ?? prop;
+      const fn = fnByName.get(fnName);
+      if (!fn || fn.access !== "public")
+        return;
+      return async (args = {}, options) => {
+        const clarityArgs = buildFunctionArgs(fn, args);
+        return callContract(client, {
+          contract: contractId,
+          functionName: fn.name,
+          functionArgs: clarityArgs,
+          ...options
+        });
+      };
+    }
+  });
+  const buildCall = new Proxy({}, {
+    get(_target, prop) {
+      const fnName = camelToKebab.get(prop) ?? prop;
+      const fn = fnByName.get(fnName);
+      if (!fn || fn.access !== "public")
+        return;
+      return async (args = {}, options) => {
+        const publicKey = options?.publicKey ?? client.account?.publicKey;
+        if (!publicKey) {
+          throw new Error("buildCall requires a publicKey (pass options.publicKey or configure a client account)");
+        }
+        const functionArgs = buildFunctionArgs(fn, args);
+        const network = client.chain?.network ?? "mainnet";
+        const nonce = options?.nonce ?? await getNonce(client, {
+          address: publicKeyToAddress(publicKey, network)
+        });
+        const unsigned = buildContractCall({
+          contractAddress: address,
+          contractName,
+          functionName: fn.name,
+          functionArgs,
+          fee: options?.fee ?? 0n,
+          nonce,
+          publicKey,
+          chain: client.chain,
+          postConditionMode: options?.postConditionMode,
+          postConditions: options?.postConditions,
+          sponsored: options?.sponsored
+        });
+        if (options?.fee === undefined) {
+          const { fee } = await resolveFee(client, unsigned, undefined);
+          setUnsignedFee(unsigned, fee);
+        }
+        return unsigned;
+      };
+    }
+  });
+  const maps = new Proxy({}, {
+    get(_target, prop) {
+      const mapName = camelToKebab.get(prop) ?? prop;
+      const map = mapByName.get(mapName);
+      if (!map)
+        return;
+      return async (key) => {
+        const clarityKey = jsToClarityValue(map.key, key);
+        const result = await getMapEntry(client, {
+          contract: contractId,
+          mapName: map.name,
+          key: clarityKey
+        });
+        if (result.type === "none")
+          return null;
+        if (result.type === "some") {
+          return clarityValueToJSUntyped(map.value, result.value);
+        }
+        return clarityValueToJSUntyped(map.value, result);
+      };
+    }
+  });
+  return { read, call, buildCall, maps };
+}
+function resolveNetworkContract(client, contracts) {
+  if (!client.chain) {
+    throw new Error("Client must have a chain configured");
+  }
+  return contracts[client.chain.network];
+}
+function buildFunctionArgs(fn, args = {}) {
+  return fn.args.map((arg) => {
+    const camelKey = toCamelCase(arg.name);
+    const hasOriginal = arg.name in args;
+    const hasCamel = camelKey in args;
+    const value = hasOriginal ? args[arg.name] : hasCamel ? args[camelKey] : undefined;
+    if (value === undefined)
+      throw new Error(`Missing argument: ${arg.name}`);
+    return jsToClarityValue(arg.type, value);
+  });
+}
+function isResponseOutput(type) {
+  return typeof type === "object" && type !== null && "response" in type;
+}
+function formatErrValue(value) {
+  if (typeof value === "bigint")
+    return value.toString();
+  if (typeof value === "string")
+    return `"${value}"`;
+  return String(value);
+}
+
+class ContractResponseError extends Error {
+  errorValue;
+  name = "ContractResponseError";
+  constructor(message, errorValue) {
+    super(message);
+    this.errorValue = errorValue;
+  }
 }
+
 // src/pox5/abi.ts
 var POX5_ABI = {
   functions: [
@@ -1603,8 +4985,222 @@ async function eligiblePauseRewards(client, params) {
   return { ok: true };
 }
 // src/pox5/script.ts
-var import_sha2 = require("@noble/hashes/sha2.js");
-var import_base = require("@scure/base");
+var import_sha25 = require("@noble/hashes/sha2.js");
+var import_base6 = require("@scure/base");
+
+// src/bitcoin/address.ts
+var import_secp256k13 = require("@noble/curves/secp256k1.js");
+var import_base5 = require("@scure/base");
+
+// src/bitcoin/serialize.ts
+function doubleSha256(bytes) {
+  return import_sha22.sha256(import_sha22.sha256(bytes));
+}
+function reverseBytes(bytes) {
+  const out = new Uint8Array(bytes.length);
+  for (let i = 0;i < bytes.length; i++) {
+    out[i] = bytes[bytes.length - 1 - i];
+  }
+  return out;
+}
+
+class BtcReader {
+  data;
+  view;
+  offset = 0;
+  constructor(data) {
+    this.data = data;
+    this.view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  }
+  get length() {
+    return this.data.length;
+  }
+  readUInt8() {
+    const v = this.view.getUint8(this.offset);
+    this.offset += 1;
+    return v;
+  }
+  peekUInt8() {
+    return this.view.getUint8(this.offset);
+  }
+  readUInt32LE() {
+    const v = this.view.getUint32(this.offset, true);
+    this.offset += 4;
+    return v;
+  }
+  readUInt64LE() {
+    const v = this.view.getBigUint64(this.offset, true);
+    this.offset += 8;
+    return v;
+  }
+  readBytes(n) {
+    if (this.offset + n > this.data.length) {
+      throw new Error(`Bitcoin tx underflow: need ${n} bytes at offset ${this.offset}, have ${this.data.length}`);
+    }
+    const slice = this.data.slice(this.offset, this.offset + n);
+    this.offset += n;
+    return slice;
+  }
+  readVarInt() {
+    const first = this.readUInt8();
+    if (first < 253)
+      return first;
+    if (first === 253) {
+      const v = this.view.getUint16(this.offset, true);
+      this.offset += 2;
+      return v;
+    }
+    if (first === 254) {
+      return this.readUInt32LE();
+    }
+    const big = this.readUInt64LE();
+    if (big > BigInt(Number.MAX_SAFE_INTEGER)) {
+      throw new Error("Bitcoin varint exceeds safe integer range");
+    }
+    return Number(big);
+  }
+}
+function scanTx(rawTx) {
+  const r = new BtcReader(rawTx);
+  const version = r.readUInt32LE();
+  let hasWitness = false;
+  if (r.peekUInt8() === 0) {
+    r.readUInt8();
+    const flag = r.readUInt8();
+    if (flag !== 1) {
+      throw new Error(`Unexpected SegWit flag 0x${flag.toString(16)}`);
+    }
+    hasWitness = true;
+  }
+  const bodyStart = r.offset;
+  const inputCount = r.readVarInt();
+  const inputs = [];
+  for (let i = 0;i < inputCount; i++) {
+    const prevTxid = r.readBytes(32);
+    const vout = r.readUInt32LE();
+    const scriptSig = r.readBytes(r.readVarInt());
+    const sequence = r.readUInt32LE();
+    inputs.push({ prevTxid, vout, scriptSig, sequence });
+  }
+  const outputCount = r.readVarInt();
+  const outputs = [];
+  for (let i = 0;i < outputCount; i++) {
+    const value = r.readUInt64LE();
+    const scriptPubKey = r.readBytes(r.readVarInt());
+    outputs.push({ value, scriptPubKey });
+  }
+  const bodyEnd = r.offset;
+  if (hasWitness) {
+    for (let i = 0;i < inputCount; i++) {
+      const itemCount = r.readVarInt();
+      for (let j = 0;j < itemCount; j++) {
+        r.readBytes(r.readVarInt());
+      }
+    }
+  }
+  const locktime = r.readUInt32LE();
+  const legacy = concatBytes(rawTx.slice(0, 4), rawTx.slice(bodyStart, bodyEnd), rawTx.slice(r.offset - 4, r.offset));
+  return { version, hasWitness, inputs, outputs, locktime, legacy };
+}
+function parseBitcoinTx(rawTx) {
+  const s = scanTx(rawTx);
+  return {
+    version: s.version,
+    hasWitness: s.hasWitness,
+    inputs: s.inputs,
+    outputs: s.outputs,
+    locktime: s.locktime,
+    txidInternal: doubleSha256(s.legacy)
+  };
+}
+function stripWitness(rawTx) {
+  return scanTx(rawTx).legacy;
+}
+function bitcoinTxid(rawTx, { display = false } = {}) {
+  const txid2 = doubleSha256(scanTx(rawTx).legacy);
+  return display ? reverseBytes(txid2) : txid2;
+}
+function parseBlockHeader(header) {
+  if (header.length !== 80) {
+    throw new Error(`Bitcoin block header must be 80 bytes, got ${header.length}`);
+  }
+  const r = new BtcReader(header);
+  const version = r.readUInt32LE();
+  const prevBlock = r.readBytes(32);
+  const merkleRoot = r.readBytes(32);
+  const timestamp = r.readUInt32LE();
+  const bits = r.readUInt32LE();
+  const nonce = r.readUInt32LE();
+  return { version, prevBlock, merkleRoot, timestamp, bits, nonce };
+}
+function blockHash(header, { display = false } = {}) {
+  const hash = doubleSha256(header);
+  return display ? reverseBytes(hash) : hash;
+}
+
+// src/bitcoin/address.ts
+var BITCOIN_NETWORK_PARAMS = {
+  mainnet: { p2pkh: 0, p2sh: 5, hrp: "bc" },
+  testnet: { p2pkh: 111, p2sh: 196, hrp: "tb" },
+  regtest: { p2pkh: 111, p2sh: 196, hrp: "bcrt" }
+};
+var NETWORK_PARAMS = BITCOIN_NETWORK_PARAMS;
+function base58CheckEncode(version, payload) {
+  const data = concatBytes(Uint8Array.of(version), payload);
+  const checksum = doubleSha256(data).slice(0, 4);
+  return import_base5.base58.encode(concatBytes(data, checksum));
+}
+function formatBitcoinAddress(parsed, network = "mainnet") {
+  const params = NETWORK_PARAMS[network];
+  const hash = parsed.hash;
+  if (!hash)
+    return;
+  switch (parsed.type) {
+    case "p2pkh":
+      return base58CheckEncode(params.p2pkh, hash);
+    case "p2sh":
+      return base58CheckEncode(params.p2sh, hash);
+    case "p2wpkh":
+    case "p2wsh":
+      return import_base5.bech32.encode(params.hrp, [0, ...import_base5.bech32.toWords(hash)]);
+    case "p2tr":
+      return import_base5.bech32m.encode(params.hrp, [1, ...import_base5.bech32m.toWords(hash)]);
+    default:
+      return;
+  }
+}
+function toPubkeyBytes(publicKey) {
+  return typeof publicKey === "string" ? hexToBytes(publicKey) : publicKey;
+}
+function taprootTweakPubkey(xonly) {
+  if (xonly.length !== 32)
+    throw new Error(`Expected 32-byte x-only pubkey, got ${xonly.length}`);
+  const tweak = import_secp256k13.schnorr.utils.taggedHash("TapTweak", xonly);
+  const t = BigInt(`0x${Array.from(tweak, (b) => b.toString(16).padStart(2, "0")).join("")}`);
+  if (t >= import_secp256k13.secp256k1.Point.Fn.ORDER)
+    throw new Error("Invalid tap tweak (exceeds curve order)");
+  const internal = import_secp256k13.secp256k1.Point.fromBytes(concatBytes(Uint8Array.of(2), xonly));
+  const output = internal.add(import_secp256k13.secp256k1.Point.BASE.multiply(t));
+  return output.toBytes(true).slice(1);
+}
+function publicKeyToP2wpkhAddress(publicKey, network = "mainnet") {
+  const pubkey = toPubkeyBytes(publicKey);
+  if (pubkey.length !== 33)
+    throw new Error(`Expected 33-byte compressed pubkey, got ${pubkey.length}`);
+  const params = NETWORK_PARAMS[network];
+  return import_base5.bech32.encode(params.hrp, [0, ...import_base5.bech32.toWords(hash160(pubkey))]);
+}
+function publicKeyToP2trAddress(publicKey, network = "mainnet") {
+  const pubkey = toPubkeyBytes(publicKey);
+  const xonly = pubkey.length === 33 ? pubkey.slice(1) : pubkey.length === 32 ? pubkey : undefined;
+  if (!xonly)
+    throw new Error(`Expected 33-byte compressed or 32-byte x-only pubkey, got ${pubkey.length}`);
+  const params = NETWORK_PARAMS[network];
+  const outputKey = taprootTweakPubkey(xonly);
+  return import_base5.bech32m.encode(params.hrp, [1, ...import_base5.bech32m.toWords(outputKey)]);
+}
+
+// src/pox5/script.ts
 function serializeCScriptNum(n) {
   const big = typeof n === "bigint" ? n : BigInt(n);
   if (big < 0n)
@@ -1649,7 +5245,7 @@ function stakerConsensusBuff(stxAddress) {
   return serializeCVBytes(Cl.principal(stxAddress));
 }
 function stakerPreimage(stxAddress) {
-  return import_sha2.sha256(stakerConsensusBuff(stxAddress));
+  return import_sha25.sha256(stakerConsensusBuff(stxAddress));
 }
 function toBytes3(input) {
   return typeof input === "string" ? hexToBytes(input) : input;
@@ -1662,17 +5258,17 @@ function buildLockupScript(opts) {
   if (height >= BITCOIN_LOCKTIME_THRESHOLD) {
     throw new Error("unlockBurnHeight >= 500,000,000 would be read by Bitcoin as a timestamp (contract rejects it)");
   }
-  const stakerHash = import_sha2.sha256(stakerPreimage(opts.stxAddress));
+  const stakerHash = import_sha25.sha256(stakerPreimage(opts.stxAddress));
   return concatBytes(Uint8Array.of(99), pushCScriptNum(height), Uint8Array.of(177, 103), hexToBytes("82012088a820"), stakerHash, Uint8Array.of(136), toBytes3(opts.earlyUnlockBytes), Uint8Array.of(104, 105), toBytes3(opts.stakerUnlockBytes));
 }
 function buildLockupOutputScript(opts) {
-  return concatBytes(Uint8Array.of(0, 32), import_sha2.sha256(buildLockupScript(opts)));
+  return concatBytes(Uint8Array.of(0, 32), import_sha25.sha256(buildLockupScript(opts)));
 }
 function buildLockupAddress(opts, network = "mainnet") {
-  const hash = import_sha2.sha256(buildLockupScript(opts));
-  return import_base.bech32.encode(BITCOIN_NETWORK_PARAMS[network].hrp, [
+  const hash = import_sha25.sha256(buildLockupScript(opts));
+  return import_base6.bech32.encode(BITCOIN_NETWORK_PARAMS[network].hrp, [
     0,
-    ...import_base.bech32.toWords(hash)
+    ...import_base6.bech32.toWords(hash)
   ]);
 }
 function buildDefaultStakerUnlockBytes(publicKey) {
@@ -1703,7 +5299,45 @@ function buildRegisterMetadata(opts) {
   };
 }
 // src/pox5/grants.ts
-var import_secp256k1 = require("@noble/curves/secp256k1.js");
+var import_secp256k14 = require("@noble/curves/secp256k1.js");
+
+// src/clarity/structuredData.ts
+var import_sha26 = require("@noble/hashes/sha2.js");
+var SIP018_PREFIX = new Uint8Array([
+  83,
+  73,
+  80,
+  48,
+  49,
+  56
+]);
+function hashStructuredData(structuredData) {
+  return import_sha26.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_sha26.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/pox5/grants.ts
 function computeSignerGrantHash(opts) {
   return structuredDataHash({
     domain: Cl.tuple({
@@ -1731,17 +5365,236 @@ function verifySignerGrant(opts) {
       return false;
     const pubkey = typeof opts.publicKey === "string" ? hexToBytes(opts.publicKey) : opts.publicKey;
     const hash = computeSignerGrantHash(opts);
-    const recovered = import_secp256k1.secp256k1.Signature.fromBytes(sig.slice(0, 64)).addRecoveryBit(sig[64]).recoverPublicKey(hash).toBytes(true);
+    const recovered = import_secp256k14.secp256k1.Signature.fromBytes(sig.slice(0, 64)).addRecoveryBit(sig[64]).recoverPublicKey(hash).toBytes(true);
     return bytesToHex(recovered) === bytesToHex(pubkey);
   } catch {
     return false;
   }
 }
 // src/pox5/lockProof.ts
-var import_sha22 = require("@noble/hashes/sha2.js");
+var import_sha27 = require("@noble/hashes/sha2.js");
+
+// src/bitcoin/merkle.ts
+function hashPair(left, right) {
+  return doubleSha256(concatBytes(left, right));
+}
+function nextLevel(level) {
+  const next = [];
+  for (let i = 0;i < level.length; i += 2) {
+    const left = level[i];
+    if (left === undefined)
+      throw new Error("merkle: missing left node");
+    const right = level[i + 1] ?? left;
+    next.push(hashPair(left, right));
+  }
+  return next;
+}
+function merkleRoot(txidsInternal) {
+  if (txidsInternal.length === 0) {
+    throw new Error("merkleRoot: empty tx list");
+  }
+  let level = txidsInternal.slice();
+  while (level.length > 1) {
+    level = nextLevel(level);
+  }
+  const root = level[0];
+  if (root === undefined)
+    throw new Error("merkleRoot: no root");
+  return root;
+}
+function buildMerkleProof(txidsInternal, txIndex) {
+  const txCount = txidsInternal.length;
+  if (txCount === 0) {
+    throw new Error("buildMerkleProof: empty tx list");
+  }
+  if (txIndex < 0 || txIndex >= txCount) {
+    throw new Error(`buildMerkleProof: txIndex ${txIndex} out of range for ${txCount} txs`);
+  }
+  const siblings = [];
+  let index = txIndex;
+  let level = txidsInternal.slice();
+  while (level.length > 1) {
+    const isRight = index % 2 === 1;
+    const siblingIndex = isRight ? index - 1 : index + 1;
+    const self = level[index];
+    if (self === undefined)
+      throw new Error("buildMerkleProof: missing node");
+    siblings.push(level[siblingIndex] ?? self);
+    level = nextLevel(level);
+    index = Math.floor(index / 2);
+  }
+  return { siblings, txIndex, txCount };
+}
+function rootFromProof(leafInternal, proof) {
+  let hash = leafInternal;
+  let index = proof.txIndex;
+  for (const sibling of proof.siblings) {
+    hash = index % 2 === 1 ? hashPair(sibling, hash) : hashPair(hash, sibling);
+    index = Math.floor(index / 2);
+  }
+  return hash;
+}
+
+// src/bitcoin/proof.ts
+function normalizeTxid2(txid2) {
+  return without0x(txid2).toLowerCase();
+}
+function assembleBlockForTx(args) {
+  const txIndex = args.txidsDisplay.indexOf(normalizeTxid2(args.txid));
+  if (txIndex < 0) {
+    throw new Error(`tx ${args.txid} not found in block ${args.blockId}`);
+  }
+  return {
+    header: hexToBytes(args.headerHex),
+    height: args.height,
+    txidsInternal: args.txidsDisplay.map((t) => reverseBytes(hexToBytes(t))),
+    txIndex
+  };
+}
+async function buildTxProof(source, params) {
+  const { txid: txid2, vout } = params;
+  const want = normalizeTxid2(txid2);
+  const [rawTx, block] = await Promise.all([
+    source.getRawTx(txid2),
+    source.getBlockForTx(txid2)
+  ]);
+  const parsed = parseBitcoinTx(rawTx);
+  const gotDisplay = bytesToHex(reverseBytes(parsed.txidInternal));
+  if (gotDisplay !== want) {
+    throw new Error(`source returned a tx whose id ${gotDisplay} does not match requested ${want}`);
+  }
+  const atIndex = block.txidsInternal[block.txIndex];
+  if (!atIndex || bytesToHex(atIndex) !== bytesToHex(parsed.txidInternal)) {
+    throw new Error(`source txIndex ${block.txIndex} does not point at tx ${want}`);
+  }
+  const merkle = buildMerkleProof(block.txidsInternal, block.txIndex);
+  const headerRoot = parseBlockHeader(block.header).merkleRoot;
+  const computed = rootFromProof(parsed.txidInternal, merkle);
+  if (bytesToHex(computed) !== bytesToHex(headerRoot)) {
+    throw new Error("constructed merkle proof does not reconcile with the block header merkle root");
+  }
+  return {
+    rawTx,
+    txidInternal: parsed.txidInternal,
+    vout,
+    merkle,
+    header: block.header,
+    height: block.height
+  };
+}
+function fallbackProofSource(sources) {
+  if (sources.length === 0) {
+    throw new Error("fallbackProofSource: at least one source is required");
+  }
+  async function firstSuccess(fn) {
+    let lastError;
+    for (const source of sources) {
+      try {
+        return await fn(source);
+      } catch (error) {
+        lastError = error;
+      }
+    }
+    throw lastError;
+  }
+  return {
+    getRawTx: (txid2) => firstSuccess((s) => s.getRawTx(txid2)),
+    getBlockForTx: (txid2) => firstSuccess((s) => s.getBlockForTx(txid2))
+  };
+}
+function bitcoinRpcSource(config) {
+  const doFetch = config.fetch ?? fetch;
+  async function rpc(method, rpcParams) {
+    const headers = {
+      "content-type": "application/json"
+    };
+    if (config.auth) {
+      const basic = typeof config.auth === "string" ? config.auth : btoa(`${config.auth.username}:${config.auth.password}`);
+      headers.authorization = `Basic ${basic}`;
+    }
+    const res = await doFetch(config.url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        jsonrpc: "1.0",
+        id: "secondlayer",
+        method,
+        params: rpcParams
+      })
+    });
+    if (!res.ok) {
+      throw new Error(`bitcoin rpc ${method} failed: HTTP ${res.status}`);
+    }
+    const json = await res.json();
+    if (json.error) {
+      throw new Error(`bitcoin rpc ${method} error: ${json.error.message}`);
+    }
+    return json.result;
+  }
+  return {
+    async getRawTx(txid2) {
+      return hexToBytes(await rpc("getrawtransaction", [txid2, false]));
+    },
+    async getBlockForTx(txid2) {
+      const tx = await rpc("getrawtransaction", [
+        txid2,
+        true
+      ]);
+      if (!tx.blockhash) {
+        throw new Error(`tx ${txid2} is not in a block (node needs -txindex, or the tx is unconfirmed)`);
+      }
+      const block = await rpc("getblock", [
+        tx.blockhash,
+        1
+      ]);
+      const header = await rpc("getblockheader", [tx.blockhash, false]);
+      return assembleBlockForTx({
+        txid: txid2,
+        blockId: tx.blockhash,
+        headerHex: header,
+        height: block.height,
+        txidsDisplay: block.tx
+      });
+    }
+  };
+}
+function esploraSource(config) {
+  const doFetch = config.fetch ?? fetch;
+  const base = config.url.replace(/\/+$/, "");
+  async function get(path) {
+    const res = await doFetch(`${base}${path}`);
+    if (!res.ok) {
+      throw new Error(`esplora GET ${path} failed: HTTP ${res.status}`);
+    }
+    return res;
+  }
+  return {
+    async getRawTx(txid2) {
+      return hexToBytes((await (await get(`/tx/${txid2}/hex`)).text()).trim());
+    },
+    async getBlockForTx(txid2) {
+      const status = await (await get(`/tx/${txid2}`)).json();
+      if (!status.status.confirmed) {
+        throw new Error(`tx ${txid2} is unconfirmed`);
+      }
+      const blockHashHex = status.status.block_hash;
+      const header = (await (await get(`/block/${blockHashHex}/header`)).text()).trim();
+      const txids = await (await get(`/block/${blockHashHex}/txids`)).json();
+      return assembleBlockForTx({
+        txid: txid2,
+        blockId: blockHashHex,
+        headerHex: header,
+        height: status.status.block_height,
+        txidsDisplay: txids
+      });
+    }
+  };
+}
+
+// src/pox5/lockProof.ts
 var MAX_LEAF_HASHES2 = 14;
 function lockupScriptPubKey(lockScript) {
-  return concatBytes(Uint8Array.of(0, 32), import_sha22.sha256(lockScript));
+  return concatBytes(Uint8Array.of(0, 32), import_sha27.sha256(lockScript));
 }
 function scriptsEqual(a, b) {
   return bytesToHex(a) === bytesToHex(b);
@@ -1800,9 +5653,9 @@ async function buildPox5LockProof(opts) {
   });
 }
 // src/pox5/reclaim.ts
-var import_sha23 = require("@noble/hashes/sha2.js");
+var import_sha28 = require("@noble/hashes/sha2.js");
 var btc = __toESM(require("@scure/btc-signer"));
-var import_utils = require("@scure/btc-signer/utils.js");
+var import_utils5 = require("@scure/btc-signer/utils.js");
 var SIGHASH_ALL = 1;
 var DUST_LIMIT_SATS = 546n;
 var ELSE_SELECTOR = new Uint8Array(0);
@@ -1830,7 +5683,7 @@ function bytesEqual(a, b) {
   return bytesToHex(a) === bytesToHex(b);
 }
 function scriptToWshOutput(lockScript) {
-  return concatBytes(Uint8Array.of(0, 32), import_sha23.sha256(lockScript));
+  return concatBytes(Uint8Array.of(0, 32), import_sha28.sha256(lockScript));
 }
 var SCAFFOLD_PREFIX_LEN = 10;
 function decodeLockScript(script) {
@@ -1898,7 +5751,7 @@ function computeReclaimSighash(tx, opts) {
 }
 function signReclaim(sighash, privateKey, opts) {
   const priv = toPrivBytes(privateKey);
-  return concatBytes(import_utils.signECDSA(sighash, priv, opts?.lowR ?? false), Uint8Array.of(SIGHASH_ALL));
+  return concatBytes(import_utils5.signECDSA(sighash, priv, opts?.lowR ?? false), Uint8Array.of(SIGHASH_ALL));
 }
 function finalizeReclaim(opts) {
   const { tx } = opts;
@@ -1963,6 +5816,48 @@ function reclaim(opts) {
   }
   return finalizeReclaim({ path: "locktime", tx });
 }
+// src/actions/public/multicall.ts
+async function mapWithConcurrency(items, limit, fn) {
+  const results = new Array(items.length);
+  let cursor = 0;
+  const worker = async () => {
+    while (cursor < items.length) {
+      const index = cursor++;
+      try {
+        results[index] = {
+          status: "fulfilled",
+          value: await fn(items[index])
+        };
+      } catch (reason) {
+        results[index] = { status: "rejected", reason };
+      }
+    }
+  };
+  const workers = Math.max(1, Math.min(limit, items.length));
+  await Promise.all(Array.from({ length: workers }, worker));
+  return results;
+}
+async function multicall(client, params) {
+  const { calls, allowFailure = true, concurrency = 8 } = params;
+  if (!Number.isInteger(concurrency) || concurrency < 1) {
+    throw new RangeError(`multicall concurrency must be a positive integer, got ${concurrency}`);
+  }
+  const settled = await mapWithConcurrency(calls, concurrency, (call) => readContract(client, call));
+  if (allowFailure) {
+    return settled.map((r) => r.status === "fulfilled" ? { status: "success", result: r.value } : {
+      status: "failure",
+      error: r.reason instanceof Error ? r.reason : new Error(String(r.reason))
+    });
+  }
+  const results = [];
+  for (const r of settled) {
+    if (r.status === "rejected")
+      throw r.reason;
+    results.push(r.value);
+  }
+  return results;
+}
+
 // src/pox5/extension.ts
 async function getStakerState(client, staker) {
   const contract = pox5ContractId(client);
@@ -2047,6 +5942,136 @@ function pox5() {
     }
   });
 }
+// src/pox5/btcAddress.ts
+var import_base7 = require("@scure/base");
+
+// src/pox/constants.ts
+var POX_CONTRACTS = {
+  mainnet: {
+    address: "SP000000000000000000002Q6VF78",
+    name: "pox-4"
+  },
+  testnet: {
+    address: "ST000000000000000000002AMW42H",
+    name: "pox-4"
+  }
+};
+var MIN_LOCK_PERIOD = 1;
+var MAX_LOCK_PERIOD = 12;
+var POX_ADDRESS_VERSION = {
+  p2pkh: 0,
+  p2sh: 1,
+  p2sh_p2wpkh: 2,
+  p2sh_p2wsh: 3,
+  p2wpkh: 4,
+  p2wsh: 5,
+  p2tr: 6
+};
+
+// src/pox5/btcAddress.ts
+function expectedHashLen(version) {
+  if (!Number.isInteger(version) || version < 0 || version > 6) {
+    throw new Error(`Unknown PoX address version: 0x${version.toString(16)}`);
+  }
+  return version <= 4 ? 20 : 32;
+}
+function canonicalizeBtcAddress(repr) {
+  const expected = expectedHashLen(repr.version);
+  const { hashbytes } = repr;
+  if (hashbytes.length === expected)
+    return { version: repr.version, hashbytes };
+  if (expected === 20 && hashbytes.length === 32 && hashbytes.slice(20).every((b) => b === 0)) {
+    return { version: repr.version, hashbytes: hashbytes.slice(0, 20) };
+  }
+  throw new Error(`Invalid hashbytes length for PoX version 0x${repr.version.toString(16)}: ${hashbytes.length}`);
+}
+function parseBtcAddress(address) {
+  if (address.startsWith("bc1") || address.startsWith("tb1") || address.startsWith("bcrt1")) {
+    return parseSegwitAddress(address);
+  }
+  return parseLegacyAddress(address);
+}
+function parseSegwitAddress(address) {
+  let decoded;
+  try {
+    decoded = import_base7.bech32.decode(address);
+  } catch {
+    decoded = import_base7.bech32m.decode(address);
+  }
+  const witnessVersion = decoded.words[0];
+  if (witnessVersion === undefined) {
+    throw new Error("Invalid segwit address: missing witness version");
+  }
+  const data = import_base7.bech32.fromWords(decoded.words.slice(1));
+  const hashbytes = new Uint8Array(data);
+  let version;
+  if (witnessVersion === 0) {
+    if (hashbytes.length === 20) {
+      version = POX_ADDRESS_VERSION.p2wpkh;
+    } else if (hashbytes.length === 32) {
+      version = POX_ADDRESS_VERSION.p2wsh;
+    } else {
+      throw new Error(`Invalid witness v0 program length: ${hashbytes.length}`);
+    }
+  } else if (witnessVersion === 1) {
+    if (hashbytes.length !== 32) {
+      throw new Error(`Invalid witness v1 program length: ${hashbytes.length}`);
+    }
+    version = POX_ADDRESS_VERSION.p2tr;
+  } else {
+    throw new Error(`Unsupported witness version: ${witnessVersion}`);
+  }
+  return { version, hashbytes };
+}
+function parseLegacyAddress(address) {
+  const decoded = import_base7.base58.decode(address);
+  if (decoded.length !== 25) {
+    throw new Error(`Invalid legacy address length: ${decoded.length}`);
+  }
+  const versionByte = decoded[0];
+  if (versionByte === undefined) {
+    throw new Error("Invalid legacy address: missing version byte");
+  }
+  const payload = decoded.slice(0, 21);
+  const checksum = decoded.slice(21);
+  const expected = doubleSha256(payload).slice(0, 4);
+  if (checksum.length !== 4 || expected.some((b, i) => b !== checksum[i])) {
+    throw new Error("Invalid legacy address checksum");
+  }
+  const hashbytes = decoded.slice(1, 21);
+  let version;
+  if (versionByte === 0 || versionByte === 111) {
+    version = POX_ADDRESS_VERSION.p2pkh;
+  } else if (versionByte === 5 || versionByte === 196) {
+    version = POX_ADDRESS_VERSION.p2sh;
+  } else {
+    throw new Error(`Unknown legacy address version byte: 0x${versionByte.toString(16)}`);
+  }
+  return { version, hashbytes };
+}
+function stringifyBtcAddress(repr, network) {
+  const { version, hashbytes } = canonicalizeBtcAddress(repr);
+  const params = BITCOIN_NETWORK_PARAMS[network];
+  switch (version) {
+    case POX_ADDRESS_VERSION.p2pkh:
+      return base58CheckEncode(params.p2pkh, hashbytes);
+    case POX_ADDRESS_VERSION.p2sh:
+    case POX_ADDRESS_VERSION.p2sh_p2wpkh:
+    case POX_ADDRESS_VERSION.p2sh_p2wsh:
+      return base58CheckEncode(params.p2sh, hashbytes);
+    case POX_ADDRESS_VERSION.p2wpkh:
+    case POX_ADDRESS_VERSION.p2wsh:
+      return import_base7.bech32.encode(params.hrp, [0, ...import_base7.bech32.toWords(hashbytes)]);
+    case POX_ADDRESS_VERSION.p2tr:
+      return import_base7.bech32m.encode(params.hrp, [1, ...import_base7.bech32m.toWords(hashbytes)]);
+    default:
+      throw new Error(`Unknown PoX address version: 0x${version.toString(16)}`);
+  }
+}
+var BtcAddress = {
+  parse: parseBtcAddress,
+  stringify: stringifyBtcAddress
+};
 // src/pox5/signerCalldata.ts
 function buildSignerCalldata(opts) {
   const repr = canonicalizeBtcAddress(typeof opts.poxAddress === "string" ? parseBtcAddress(opts.poxAddress) : opts.poxAddress);
@@ -2096,5 +6121,5 @@ function parseSignerCalldata(calldata) {
   };
 }
 
-//# debugId=90830B6EA47D48EC64756E2164756E21
+//# debugId=9618E4E75187B7DD64756E2164756E21
 //# sourceMappingURL=index.cjs.map