@secondlayer/stacks 0.2.2 → 1.0.0-alpha.0

package/dist/src/tools/index.js

@@ -0,0 +1,2435 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/tools/index.ts
+import { tool } from "ai";
+import { z } from "zod";
+
+// src/utils/c32.ts
+import { sha256 } from "@noble/hashes/sha2.js";
+
+// src/utils/encoding.ts
+var hexes = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+function bytesToHex(bytes) {
+  let hex = "";
+  for (const b of bytes) {
+    hex += hexes[b];
+  }
+  return hex;
+}
+function hexToBytes(hex) {
+  hex = without0x(hex);
+  if (hex.length % 2)
+    hex = `0${hex}`;
+  const array = new Uint8Array(hex.length / 2);
+  for (let i = 0;i < array.length; i++) {
+    const j = i * 2;
+    const byte = Number.parseInt(hex.slice(j, j + 2), 16);
+    if (Number.isNaN(byte) || byte < 0)
+      throw new Error("Invalid byte sequence");
+    array[i] = byte;
+  }
+  return array;
+}
+function with0x(value) {
+  return /^0x/i.test(value) ? value : `0x${value}`;
+}
+function without0x(value) {
+  return /^0x/i.test(value) ? value.slice(2) : value;
+}
+function utf8ToBytes(str) {
+  return new TextEncoder().encode(str);
+}
+function bytesToUtf8(bytes) {
+  return new TextDecoder().decode(bytes);
+}
+function asciiToBytes(str) {
+  const bytes = new Uint8Array(str.length);
+  for (let i = 0;i < str.length; i++) {
+    bytes[i] = str.charCodeAt(i) & 255;
+  }
+  return bytes;
+}
+function bytesToAscii(bytes) {
+  return String.fromCharCode(...bytes);
+}
+function concatBytes(...arrays) {
+  if (arrays.length === 1)
+    return arrays[0];
+  const length = arrays.reduce((a, arr) => a + arr.length, 0);
+  const result = new Uint8Array(length);
+  let pad = 0;
+  for (const arr of arrays) {
+    result.set(arr, pad);
+    pad += arr.length;
+  }
+  return result;
+}
+function intToBigInt(value) {
+  if (typeof value === "bigint")
+    return value;
+  if (typeof value === "string")
+    return BigInt(value);
+  if (typeof value === "number") {
+    if (!Number.isInteger(value))
+      throw new RangeError("Values of type 'number' must be an integer.");
+    if (value > Number.MAX_SAFE_INTEGER)
+      throw new RangeError(`Values of type 'number' must be <= ${Number.MAX_SAFE_INTEGER}. Use BigInt instead.`);
+    return BigInt(value);
+  }
+  if (value instanceof Uint8Array)
+    return BigInt(`0x${bytesToHex(value)}`);
+  throw new TypeError("Must be a number, bigint, string, or Uint8Array.");
+}
+function intToBytes(value, byteLength) {
+  return bigIntToBytes(intToBigInt(value), byteLength);
+}
+function bigIntToBytes(value, length = 16) {
+  const hex = value.toString(16).padStart(length * 2, "0");
+  return hexToBytes(hex);
+}
+function intToHex(integer, byteLength = 8) {
+  const value = typeof integer === "bigint" ? integer : intToBigInt(integer);
+  return value.toString(16).padStart(byteLength * 2, "0");
+}
+function toTwos(value, width) {
+  const limit = BigInt(1) << width - BigInt(1);
+  if (value < -limit || value > limit - BigInt(1)) {
+    throw new Error(`Unable to represent integer in width: ${width}`);
+  }
+  if (value >= BigInt(0))
+    return value;
+  return value + (BigInt(1) << width);
+}
+function fromTwos(value, width) {
+  if (value & BigInt(1) << width - BigInt(1)) {
+    return value - (BigInt(1) << width);
+  }
+  return value;
+}
+function bytesToTwosBigInt(bytes) {
+  if (bytes.length === 0)
+    return 0n;
+  const hex = bytesToHex(bytes);
+  if (hex.length === 0)
+    return 0n;
+  return fromTwos(BigInt(`0x${hex}`), BigInt(bytes.byteLength * 8));
+}
+function writeUInt32BE(value) {
+  const buf = new Uint8Array(4);
+  buf[0] = value >>> 24 & 255;
+  buf[1] = value >>> 16 & 255;
+  buf[2] = value >>> 8 & 255;
+  buf[3] = value & 255;
+  return buf;
+}
+function writeUInt16BE(value) {
+  const buf = new Uint8Array(2);
+  buf[0] = value >>> 8 & 255;
+  buf[1] = value & 255;
+  return buf;
+}
+function writeUInt8(value) {
+  return new Uint8Array([value & 255]);
+}
+
+// src/utils/c32.ts
+var C32 = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+var HEX = "0123456789abcdef";
+function c32normalize(input) {
+  return input.toUpperCase().replace(/O/g, "0").replace(/L|I/g, "1");
+}
+function c32encode(inputHex) {
+  if (inputHex.length % 2 !== 0)
+    inputHex = `0${inputHex}`;
+  inputHex = inputHex.toLowerCase();
+  const res = [];
+  let carry = 0;
+  for (let i = inputHex.length - 1;i >= 0; i--) {
+    if (carry < 4) {
+      const currentCode = HEX.indexOf(inputHex[i]) >> carry;
+      const nextCode = i !== 0 ? HEX.indexOf(inputHex[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(inputHex);
+  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) {
+  c32input = c32normalize(c32input);
+  if (!c32input.match(`^[${C32}]*$`))
+    throw new Error("Not a c32-encoded string");
+  const zeroPrefix = c32input.match(`^${C32[0]}*`);
+  const numLeadingZeroBytes = zeroPrefix ? zeroPrefix[0].length : 0;
+  const res = [];
+  let carry = 0;
+  let carryBits = 0;
+  for (let i = c32input.length - 1;i >= 0; i--) {
+    if (carryBits === 4) {
+      res.unshift(HEX[carry]);
+      carryBits = 0;
+      carry = 0;
+    }
+    const currentValue = (C32.indexOf(c32input[i]) << carryBits) + carry;
+    res.unshift(HEX[currentValue % 16]);
+    carryBits += 1;
+    carry = currentValue >> 4;
+    if (carry > 1 << carryBits)
+      throw new Error("Panic error in c32 decoding");
+  }
+  res.unshift(HEX[carry]);
+  if (res.length % 2 === 1)
+    res.unshift("0");
+  let hexLeadingZeros = 0;
+  while (hexLeadingZeros < res.length && res[hexLeadingZeros] === "0")
+    hexLeadingZeros++;
+  let hexStr = res.slice(hexLeadingZeros - hexLeadingZeros % 2).join("");
+  for (let i = 0;i < numLeadingZeroBytes; i++)
+    hexStr = `00${hexStr}`;
+  return hexStr;
+}
+function c32checksum(dataHex) {
+  return bytesToHex(sha256(sha256(hexToBytes(dataHex))).slice(0, 4));
+}
+function c32checkEncode(version, data) {
+  if (version < 0 || version >= 32)
+    throw new Error("Invalid version (must be between 0 and 31)");
+  if (!data.match(/^[0-9a-fA-F]*$/))
+    throw new Error("Invalid data (not a hex string)");
+  data = data.toLowerCase();
+  if (data.length % 2 !== 0)
+    data = `0${data}`;
+  let versionHex = version.toString(16);
+  if (versionHex.length === 1)
+    versionHex = `0${versionHex}`;
+  const checksumHex = c32checksum(`${versionHex}${data}`);
+  return `${C32[version]}${c32encode(`${data}${checksumHex}`)}`;
+}
+function c32checkDecode(c32data) {
+  c32data = c32normalize(c32data);
+  const dataHex = c32decode(c32data.slice(1));
+  const version = C32.indexOf(c32data[0]);
+  const checksum = dataHex.slice(-8);
+  let versionHex = version.toString(16);
+  if (versionHex.length === 1)
+    versionHex = `0${versionHex}`;
+  if (c32checksum(`${versionHex}${dataHex.substring(0, dataHex.length - 8)}`) !== checksum) {
+    throw new Error("Invalid c32check string: checksum mismatch");
+  }
+  return [version, dataHex.substring(0, dataHex.length - 8)];
+}
+function c32address(version, hash160hex) {
+  if (!hash160hex.match(/^[0-9a-fA-F]{40}$/)) {
+    throw new Error("Invalid argument: not a hash160 hex string");
+  }
+  return `S${c32checkEncode(version, hash160hex)}`;
+}
+function c32addressDecode(c32addr) {
+  if (c32addr.length <= 5)
+    throw new Error("Invalid c32 address: invalid length");
+  if (c32addr[0] !== "S")
+    throw new Error('Invalid c32 address: must start with "S"');
+  return c32checkDecode(c32addr.slice(1));
+}
+
+// src/clarity/types.ts
+var ClarityWireType = {
+  int: 0,
+  uint: 1,
+  buffer: 2,
+  true: 3,
+  false: 4,
+  address: 5,
+  contract: 6,
+  ok: 7,
+  err: 8,
+  none: 9,
+  some: 10,
+  list: 11,
+  tuple: 12,
+  ascii: 13,
+  utf8: 14
+};
+var wireTypeToClarity = Object.fromEntries(Object.entries(ClarityWireType).map(([k, v]) => [v, k]));
+function clarityTypeFromByte(byte) {
+  const type = wireTypeToClarity[byte];
+  if (!type)
+    throw new Error(`Unknown clarity wire type: ${byte}`);
+  return type;
+}
+
+// src/clarity/serialize.ts
+var CLARITY_INT_SIZE = 128n;
+var CLARITY_INT_BYTE_SIZE = 16;
+function typeIdByte(type) {
+  return ClarityWireType[type];
+}
+function withTypeId(type, bytes) {
+  return concatBytes(new Uint8Array([typeIdByte(type)]), bytes);
+}
+function serializeAddress(c32Address) {
+  const [version, hash160] = c32addressDecode(c32Address);
+  return concatBytes(new Uint8Array([version]), hexToBytes(hash160));
+}
+function serializeLPString(str, prefixBytes = 1) {
+  const content = utf8ToBytes(str);
+  const lengthPrefix = hexToBytes(intToHex(content.byteLength, prefixBytes));
+  return concatBytes(lengthPrefix, content);
+}
+function serializeCVBytes(value) {
+  switch (value.type) {
+    case "true":
+    case "false":
+      return new Uint8Array([typeIdByte(value.type)]);
+    case "int": {
+      const bytes = bigIntToBytes(toTwos(BigInt(value.value), CLARITY_INT_SIZE), CLARITY_INT_BYTE_SIZE);
+      return withTypeId(value.type, bytes);
+    }
+    case "uint": {
+      const bytes = bigIntToBytes(BigInt(value.value), CLARITY_INT_BYTE_SIZE);
+      return withTypeId(value.type, bytes);
+    }
+    case "buffer": {
+      const bufBytes = hexToBytes(value.value);
+      return withTypeId(value.type, concatBytes(writeUInt32BE(bufBytes.length), bufBytes));
+    }
+    case "none":
+      return new Uint8Array([typeIdByte(value.type)]);
+    case "some":
+      return withTypeId(value.type, serializeCVBytes(value.value));
+    case "ok":
+    case "err":
+      return withTypeId(value.type, serializeCVBytes(value.value));
+    case "address":
+      return withTypeId(value.type, serializeAddress(value.value));
+    case "contract": {
+      const [addr, name] = value.value.split(".");
+      if (!addr || !name)
+        throw new Error(`Invalid contract principal: ${value.value}`);
+      return withTypeId(value.type, concatBytes(serializeAddress(addr), serializeLPString(name)));
+    }
+    case "list": {
+      const parts = [writeUInt32BE(value.value.length)];
+      for (const item of value.value) {
+        parts.push(serializeCVBytes(item));
+      }
+      return withTypeId(value.type, concatBytes(...parts));
+    }
+    case "tuple": {
+      const keys = Object.keys(value.value).sort((a, b) => a.localeCompare(b));
+      const parts = [writeUInt32BE(keys.length)];
+      for (const key of keys) {
+        parts.push(serializeLPString(key));
+        parts.push(serializeCVBytes(value.value[key]));
+      }
+      return withTypeId(value.type, concatBytes(...parts));
+    }
+    case "ascii": {
+      const strBytes = asciiToBytes(value.value);
+      return withTypeId(value.type, concatBytes(writeUInt32BE(strBytes.length), strBytes));
+    }
+    case "utf8": {
+      const strBytes = utf8ToBytes(value.value);
+      return withTypeId(value.type, concatBytes(writeUInt32BE(strBytes.length), strBytes));
+    }
+    default:
+      throw new Error(`Cannot serialize unknown clarity type`);
+  }
+}
+
+// src/transactions/types.ts
+var AuthType = {
+  Standard: 4,
+  Sponsored: 5
+};
+var PayloadType = {
+  TokenTransfer: 0,
+  SmartContract: 1,
+  ContractCall: 2,
+  PoisonMicroblock: 3,
+  Coinbase: 4,
+  CoinbaseToAltRecipient: 5,
+  VersionedSmartContract: 6,
+  TenureChange: 7,
+  NakamotoCoinbase: 8
+};
+var AnchorMode = {
+  OnChainOnly: 1,
+  OffChainOnly: 2,
+  Any: 3
+};
+var PostConditionModeWire = {
+  Allow: 1,
+  Deny: 2
+};
+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
+};
+var PostConditionPrincipalId = {
+  Origin: 1,
+  Standard: 2,
+  Contract: 3
+};
+var AssetType = {
+  STX: 0,
+  Fungible: 1,
+  NonFungible: 2
+};
+var RECOVERABLE_ECDSA_SIG_LENGTH_BYTES = 65;
+var MEMO_MAX_LENGTH_BYTES = 34;
+
+// src/transactions/wire/serialize.ts
+function serializeAddress2(c32Address) {
+  const [version, hash160] = c32addressDecode(c32Address);
+  return concatBytes(new Uint8Array([version]), hexToBytes(hash160));
+}
+function serializeLPString2(str, prefixBytes = 1) {
+  const content = utf8ToBytes(str);
+  const prefix = hexToBytes(intToHex(content.byteLength, prefixBytes));
+  return concatBytes(prefix, content);
+}
+function serializeLPStringLong(str) {
+  return serializeLPString2(str, 4);
+}
+function serializeMemo(memo) {
+  const content = asciiToBytes(memo);
+  const padded = new Uint8Array(MEMO_MAX_LENGTH_BYTES);
+  padded.set(content.slice(0, MEMO_MAX_LENGTH_BYTES));
+  return padded;
+}
+function serializeSpendingCondition(condition) {
+  const parts = [
+    writeUInt8(condition.hashMode),
+    hexToBytes(condition.signer),
+    intToBytes(condition.nonce, 8),
+    intToBytes(condition.fee, 8)
+  ];
+  if ("signature" in condition) {
+    const sc = condition;
+    parts.push(writeUInt8(sc.keyEncoding));
+    parts.push(hexToBytes(sc.signature));
+  } else {
+    const mc = condition;
+    parts.push(writeUInt32BE(mc.fields.length));
+    for (const field of mc.fields) {
+      parts.push(serializeAuthField(field));
+    }
+    parts.push(writeUInt16BE(mc.signaturesRequired));
+  }
+  return concatBytes(...parts);
+}
+function serializeAuthField(field) {
+  if (field.type === "publicKey") {
+    const typeId = field.pubKeyEncoding === 0 ? 0 : 1;
+    return concatBytes(writeUInt8(typeId), hexToBytes(field.data));
+  } else {
+    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 serializePostCondition(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;
+  }
+  return concatBytes(...parts);
+}
+function serializePostConditions(pcs) {
+  const parts = [writeUInt32BE(pcs.length)];
+  for (const pc of pcs) {
+    parts.push(serializePostCondition(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);
+}
+function serializeTransaction(tx) {
+  return concatBytes(writeUInt8(tx.version), writeUInt32BE(tx.chainId), serializeAuthorization(tx.auth), writeUInt8(tx.anchorMode), writeUInt8(tx.postConditionMode), serializePostConditions(tx.postConditions), serializePayload(tx.payload));
+}
+
+// src/actions/public/estimateFee.ts
+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
+    }
+  });
+  return (data.estimations ?? []).map((e) => ({
+    feeRate: e.fee_rate,
+    fee: e.fee
+  }));
+}
+
+// src/actions/public/getAccountInfo.ts
+async function getAccountInfo(client, params) {
+  const data = await client.request(`/v2/accounts/${params.address}?proof=1`, {
+    method: "GET"
+  });
+  return {
+    balance: BigInt(data.balance),
+    nonce: BigInt(data.nonce),
+    balanceProof: data.balance_proof ?? "",
+    nonceProof: data.nonce_proof ?? ""
+  };
+}
+
+// src/actions/public/getBalance.ts
+async function getBalance(client, params) {
+  const data = await client.request(`/v2/accounts/${params.address}`, {
+    method: "GET"
+  });
+  return BigInt(data.balance);
+}
+
+// src/actions/public/getBlock.ts
+async function getBlock(client, params) {
+  if (params?.hash) {
+    return client.request(`/extended/v2/blocks/${params.hash}`, {
+      method: "GET"
+    });
+  }
+  if (params?.height !== undefined) {
+    return client.request(`/extended/v2/blocks/${params.height}`, {
+      method: "GET"
+    });
+  }
+  return client.request("/extended/v2/blocks?limit=1", { method: "GET" });
+}
+
+// src/actions/public/getBlockHeight.ts
+async function getBlockHeight(client) {
+  const data = await client.request("/v2/info", { method: "GET" });
+  return data.stacks_tip_height;
+}
+
+// src/utils/bytes-reader.ts
+class BytesReader {
+  data;
+  offset = 0;
+  constructor(data) {
+    this.data = data;
+  }
+  readUInt8() {
+    return this.data[this.offset++];
+  }
+  readUInt16BE() {
+    const val = (this.data[this.offset] << 8 | this.data[this.offset + 1]) >>> 0;
+    this.offset += 2;
+    return val;
+  }
+  readUInt32BE() {
+    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) {
+    if (this.offset + length > this.data.length) {
+      throw new Error(`Buffer underflow: need ${length} bytes at offset ${this.offset}, have ${this.data.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/address.ts
+function parseContractId(contractId) {
+  const [address, name] = contractId.split(".");
+  if (!address || !name)
+    throw new Error(`Invalid contract identifier: ${contractId}`);
+  return [address, name];
+}
+function isClarityName(name) {
+  const regex = /^[a-zA-Z]([a-zA-Z0-9]|[-_!?+<>=/*])*$|^[-+=/*]$|^[<>]=?$/;
+  return regex.test(name) && name.length < 128;
+}
+
+// src/clarity/values.ts
+var MAX_U128 = BigInt("0xffffffffffffffffffffffffffffffff");
+var MIN_I128 = BigInt("-170141183460469231731687303715884105728");
+var MAX_I128 = BigInt("0x7fffffffffffffffffffffffffffffff");
+function intCV(value) {
+  if (typeof value === "string" && value.toLowerCase().startsWith("0x")) {
+    value = bytesToTwosBigInt(hexToBytes(value));
+  }
+  if (value instanceof Uint8Array)
+    value = bytesToTwosBigInt(value);
+  const n = intToBigInt(value);
+  if (n > MAX_I128)
+    throw new RangeError(`Int exceeds max i128: ${MAX_I128}`);
+  if (n < MIN_I128)
+    throw new RangeError(`Int below min i128: ${MIN_I128}`);
+  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_U128)
+    throw new RangeError(`UInt exceeds max u128: ${MAX_U128}`);
+  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, hash160] = c32addressDecode(address);
+  const normalized = c32address(version, hash160);
+  return { type: "address", value: normalized };
+}
+function contractPrincipalCV(address, contractName) {
+  const [version, hash160] = c32addressDecode(address);
+  const normalized = c32address(version, hash160);
+  if (utf8ToBytes(contractName).byteLength >= 128) {
+    throw new Error("Contract name must be less than 128 bytes");
+  }
+  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 [addr, name] = address.split(".");
+    if (!addr)
+      throw new Error("Invalid principal address");
+    return name ? contractPrincipalCV(addr, name) : standardPrincipalCV(addr);
+  },
+  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 hash160 = bytesToHex(reader.readBytes(20));
+  return c32address(version, hash160);
+}
+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));
+}
+function readCV(reader) {
+  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));
+    case "ok":
+      return responseOkCV(readCV(reader));
+    case "err":
+      return responseErrorCV(readCV(reader));
+    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();
+      const items = [];
+      for (let i = 0;i < len; i++) {
+        items.push(readCV(reader));
+      }
+      return listCV(items);
+    }
+    case "tuple": {
+      const len = reader.readUInt32BE();
+      const data = {};
+      for (let i = 0;i < len; i++) {
+        const key = readLPString(reader);
+        data[key] = readCV(reader);
+      }
+      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 Error(`Cannot deserialize unknown clarity type: ${type}`);
+  }
+}
+function deserializeCVBytes(input) {
+  const bytes = typeof input === "string" ? hexToBytes(without0x(input)) : input;
+  return readCV(new BytesReader(bytes));
+}
+
+// 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 data = await client.request(`/v2/contracts/call-read/${address}/${name}/${params.functionName}`, {
+    method: "POST",
+    body: {
+      sender,
+      arguments: serializedArgs
+    }
+  });
+  if (data.okay) {
+    return deserializeCVBytes(data.result);
+  }
+  throw new Error(data.cause ?? "Read-only call failed");
+}
+
+// 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/utils/constants.ts
+var MAX_U1282 = (1n << 128n) - 1n;
+var MAX_I1282 = (1n << 127n) - 1n;
+var MIN_I1282 = -(1n << 127n);
+
+// src/clarity/abi/guards.ts
+function isAbiList(type) {
+  return typeof type === "object" && type !== null && "list" in type;
+}
+function isAbiTuple(type) {
+  return typeof type === "object" && type !== null && "tuple" in type;
+}
+function isAbiOptional(type) {
+  return typeof type === "object" && type !== null && "optional" in type;
+}
+function isAbiResponse(type) {
+  return typeof type === "object" && type !== null && "response" in type;
+}
+function isAbiBuffer(type) {
+  return typeof type === "object" && type !== null && "buff" in type;
+}
+function isAbiStringAscii(type) {
+  return typeof type === "object" && type !== null && "string-ascii" in type;
+}
+function isAbiStringUtf8(type) {
+  return typeof type === "object" && type !== null && "string-utf8" in type;
+}
+
+// src/clarity/bridge.ts
+function jsToClarityValue(abiType, 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 (isAbiBuffer(abiType))
+    return bufferCV(value);
+  if (isAbiList(abiType)) {
+    const arr = value;
+    return listCV(arr.map((item) => jsToClarityValue(abiType.list.type, item)));
+  }
+  if (isAbiTuple(abiType)) {
+    const obj = value;
+    const data = {};
+    for (const field of abiType.tuple) {
+      const camelKey = toCamelCase(field.name);
+      const hasOriginal = field.name in obj;
+      const hasCamel = camelKey in obj;
+      const fieldValue = hasOriginal ? obj[field.name] : hasCamel ? obj[camelKey] : undefined;
+      if (fieldValue === undefined && !isAbiOptional(field.type)) {
+        throw new Error(`Missing tuple field: ${field.name}`);
+      }
+      data[field.name] = jsToClarityValue(field.type, fieldValue);
+    }
+    return tupleCV(data);
+  }
+  if (isAbiOptional(abiType)) {
+    if (value === null || value === undefined)
+      return noneCV();
+    return someCV(jsToClarityValue(abiType.optional, value));
+  }
+  if (isAbiResponse(abiType)) {
+    const obj = value;
+    if ("ok" in obj && !("err" in obj))
+      return responseOkCV(jsToClarityValue(abiType.response.ok, obj.ok));
+    if ("err" in obj && !("ok" in obj))
+      return responseErrorCV(jsToClarityValue(abiType.response.error, obj.err));
+    throw new Error("Response must have exactly 'ok' or 'err' property");
+  }
+  throw new Error(`Unknown ABI type: ${JSON.stringify(abiType)}`);
+}
+function clarityValueToJSUntyped(abiType, cv) {
+  return clarityValueToJSInner(abiType, cv);
+}
+function clarityValueToJSInner(abiType, cv) {
+  if (abiType === "uint128" || abiType === "int128") {
+    if (cv.type !== "int" && cv.type !== "uint")
+      throw new Error(`Expected int/uint CV, got ${cv.type}`);
+    return cv.value;
+  }
+  if (abiType === "bool") {
+    if (cv.type === "true")
+      return true;
+    if (cv.type === "false")
+      return false;
+    throw new Error(`Expected bool CV, got ${cv.type}`);
+  }
+  if (abiType === "principal" || abiType === "trait_reference") {
+    if (cv.type !== "address" && cv.type !== "contract")
+      throw new Error(`Expected principal CV, got ${cv.type}`);
+    return cv.value;
+  }
+  if (isAbiStringAscii(abiType) || isAbiStringUtf8(abiType)) {
+    if (cv.type !== "ascii" && cv.type !== "utf8")
+      throw new Error(`Expected string CV, got ${cv.type}`);
+    return cv.value;
+  }
+  if (isAbiBuffer(abiType)) {
+    if (cv.type !== "buffer")
+      throw new Error(`Expected buffer CV, got ${cv.type}`);
+    const hex = cv.value;
+    const bytes = new Uint8Array(hex.length / 2);
+    for (let i = 0;i < bytes.length; i++) {
+      bytes[i] = Number.parseInt(hex.substring(i * 2, i * 2 + 2), 16);
+    }
+    return bytes;
+  }
+  if (isAbiList(abiType)) {
+    if (cv.type !== "list")
+      throw new Error(`Expected list CV, got ${cv.type}`);
+    return cv.value.map((item) => clarityValueToJSInner(abiType.list.type, item));
+  }
+  if (isAbiTuple(abiType)) {
+    if (cv.type !== "tuple")
+      throw new Error(`Expected tuple CV, got ${cv.type}`);
+    const result = {};
+    for (const field of abiType.tuple) {
+      const fieldCV = cv.value[field.name];
+      if (!fieldCV)
+        throw new Error(`Missing tuple field in CV: ${field.name}`);
+      const camelKey = toCamelCase(field.name);
+      result[camelKey] = clarityValueToJSInner(field.type, fieldCV);
+    }
+    return result;
+  }
+  if (isAbiOptional(abiType)) {
+    if (cv.type === "none")
+      return null;
+    if (cv.type === "some")
+      return clarityValueToJSInner(abiType.optional, cv.value);
+    throw new Error(`Expected optional CV, got ${cv.type}`);
+  }
+  if (isAbiResponse(abiType)) {
+    if (cv.type === "ok")
+      return { ok: clarityValueToJSInner(abiType.response.ok, cv.value) };
+    if (cv.type === "err")
+      return { err: clarityValueToJSInner(abiType.response.error, cv.value) };
+    throw new Error(`Expected response CV, got ${cv.type}`);
+  }
+  throw new Error(`Unknown ABI type: ${JSON.stringify(abiType)}`);
+}
+
+// src/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
+  });
+  return deserializeCVBytes(data.data);
+}
+
+// src/transactions/authorization.ts
+import { hmac } from "@noble/hashes/hmac.js";
+import { sha256 as sha2563 } from "@noble/hashes/sha2.js";
+import { etc, getPublicKey as nobleGetPublicKey, sign } from "@noble/secp256k1";
+
+// src/utils/hash.ts
+import { ripemd160 } from "@noble/hashes/legacy.js";
+import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
+import { sha512_256 } from "@noble/hashes/sha2.js";
+function hash160(input) {
+  return ripemd160(sha2562(input));
+}
+function txidFromBytes(data) {
+  return bytesToHex(sha512_256(data));
+}
+function hashP2PKH(input) {
+  return bytesToHex(hash160(input));
+}
+
+// src/transactions/authorization.ts
+etc.hmacSha256Sync = (key, ...msgs) => {
+  const h = hmac.create(sha2563, key);
+  msgs.forEach((msg) => 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 intoInitialSighashAuth(auth) {
+  if (auth.authType === AuthType.Standard) {
+    return createStandardAuth(clearCondition(auth.spendingCondition));
+  }
+  return createSponsoredAuth(clearCondition(auth.spendingCondition), clearCondition(createSingleSigSpendingCondition("0".repeat(66), 0n, 0n)));
+}
+function sigHashPreSign(curSigHash, authType, fee, nonce) {
+  const data = concatBytes(hexToBytes(curSigHash), new Uint8Array([authType]), intToBytes(fee, 8), intToBytes(nonce, 8));
+  return txidFromBytes(data);
+}
+
+// src/transactions/multisig.ts
+import {
+  getPublicKey as nobleGetPublicKey2,
+  sign as nobleSign
+} from "@noble/secp256k1";
+var OP_CHECKMULTISIG = 174;
+function makeRedeemScript(publicKeys, signaturesRequired) {
+  const parts = [];
+  parts.push(new Uint8Array([80 + signaturesRequired]));
+  for (const pk of publicKeys) {
+    const pkBytes = hexToBytes(pk);
+    parts.push(new Uint8Array([pkBytes.length]));
+    parts.push(pkBytes);
+  }
+  parts.push(new Uint8Array([80 + publicKeys.length]));
+  parts.push(new Uint8Array([OP_CHECKMULTISIG]));
+  return concatBytes(...parts);
+}
+function createMultiSigSpendingCondition(publicKeys, signaturesRequired, nonce, fee, hashMode = AddressHashMode.P2SH) {
+  const redeemScript = makeRedeemScript(publicKeys, signaturesRequired);
+  const signer = bytesToHex(hash160(redeemScript));
+  return {
+    hashMode,
+    signer,
+    nonce,
+    fee,
+    fields: [],
+    signaturesRequired
+  };
+}
+
+// src/transactions/build.ts
+function resolvePcMode(mode) {
+  return mode === "allow" ? PostConditionModeWire.Allow : PostConditionModeWire.Deny;
+}
+function convertPostConditions(pcs) {
+  if (!pcs || pcs.length === 0)
+    return [];
+  return pcs.map(convertPostCondition);
+}
+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 };
+}
+var FUNGIBLE_CODE_MAP = {
+  eq: FungibleConditionCode.Equal,
+  gt: FungibleConditionCode.Greater,
+  gte: FungibleConditionCode.GreaterEqual,
+  lt: FungibleConditionCode.Less,
+  lte: FungibleConditionCode.LessEqual
+};
+function convertPostCondition(pc) {
+  switch (pc.type) {
+    case "stx-postcondition":
+      return {
+        type: "stx",
+        principal: resolvePrincipal(pc.address),
+        conditionCode: FUNGIBLE_CODE_MAP[pc.condition],
+        amount: intToBigInt(pc.amount)
+      };
+    case "ft-postcondition": {
+      const [contractId, tokenName] = pc.asset.split("::");
+      const [addr, name] = parseContractId(contractId);
+      return {
+        type: "ft",
+        principal: resolvePrincipal(pc.address),
+        asset: { address: addr, contractName: name, assetName: tokenName },
+        conditionCode: FUNGIBLE_CODE_MAP[pc.condition],
+        amount: intToBigInt(pc.amount)
+      };
+    }
+    case "nft-postcondition": {
+      const [contractId, tokenName] = pc.asset.split("::");
+      const [addr, name] = parseContractId(contractId);
+      return {
+        type: "nft",
+        principal: resolvePrincipal(pc.address),
+        asset: { address: addr, contractName: name, assetName: tokenName },
+        conditionCode: pc.condition === "sent" ? NonFungibleConditionCode.Sends : NonFungibleConditionCode.DoesNotSend,
+        assetId: pc.assetId
+      };
+    }
+  }
+}
+function resolveSpendingCondition(opts, nonce, fee) {
+  if (opts.publicKeys) {
+    return createMultiSigSpendingCondition(opts.publicKeys, opts.signaturesRequired, nonce, fee, opts.hashMode);
+  }
+  return createSingleSigSpendingCondition(opts.publicKey, nonce, fee);
+}
+function resolveAuth(spendingCondition, sponsored) {
+  return sponsored ? createSponsoredAuth(spendingCondition) : createStandardAuth(spendingCondition);
+}
+function resolveVersionAndChainId(chain) {
+  if (!chain)
+    return { version: 0, chainId: 1 };
+  return { version: chain.transactionVersion, chainId: chain.id };
+}
+function buildContractCall(options) {
+  const { version, chainId } = resolveVersionAndChainId(options.chain);
+  const fee = intToBigInt(options.fee);
+  const nonce = intToBigInt(options.nonce);
+  const spendingCondition = resolveSpendingCondition(options, nonce, fee);
+  const tx = {
+    version,
+    chainId,
+    auth: resolveAuth(spendingCondition, options.sponsored),
+    anchorMode: AnchorMode.Any,
+    postConditionMode: resolvePcMode(options.postConditionMode),
+    postConditions: convertPostConditions(options.postConditions),
+    payload: {
+      payloadType: PayloadType.ContractCall,
+      contractAddress: options.contractAddress,
+      contractName: options.contractName,
+      functionName: options.functionName,
+      functionArgs: options.functionArgs
+    }
+  };
+  if (options.publicKeys) {
+    tx._multisig = { publicKeys: options.publicKeys };
+  }
+  return tx;
+}
+
+// src/transactions/signer.ts
+function txid(tx) {
+  return txidFromBytes(serializeTransaction(tx));
+}
+function signBegin(tx) {
+  const cleared = {
+    ...tx,
+    auth: intoInitialSighashAuth(tx.auth)
+  };
+  return txid(cleared);
+}
+async function signTransactionWithAccount(tx, account) {
+  const sigHash = signBegin(tx);
+  const condition = tx.auth.spendingCondition;
+  const sigHashPre = sigHashPreSign(sigHash, AuthType.Standard, condition.fee, condition.nonce);
+  const sigBytes = await account.sign(hexToBytes(sigHashPre));
+  const nextSig = bytesToHex(sigBytes);
+  return {
+    ...tx,
+    auth: {
+      ...tx.auth,
+      spendingCondition: {
+        ...condition,
+        signature: nextSig
+      }
+    }
+  };
+}
+function getTransactionId(tx) {
+  return txid(tx);
+}
+
+// src/actions/public/getNonce.ts
+async function getNonce(client, params) {
+  const data = await client.request(`/v2/accounts/${params.address}`, {
+    method: "GET"
+  });
+  return BigInt(data.nonce);
+}
+
+// src/errors/base.ts
+class BaseError extends Error {
+  name = "StacksError";
+  shortMessage;
+  details;
+  constructor(shortMessage, options) {
+    const message = [
+      shortMessage,
+      options?.details ? `
+${options.details}` : ""
+    ].join("");
+    super(message, { cause: options?.cause });
+    this.shortMessage = shortMessage;
+    this.details = options?.details;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      shortMessage: this.shortMessage,
+      details: this.details,
+      cause: this.cause instanceof Error ? this.cause.message : undefined
+    };
+  }
+}
+
+// src/errors/transaction.ts
+class BroadcastError extends BaseError {
+  name = "BroadcastError";
+  txid;
+  reason;
+  constructor(message, options) {
+    super(message, options);
+    this.txid = options?.txid;
+    this.reason = options?.reason;
+  }
+}
+
+// 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);
+  }
+  const data = await client.request("/v2/transactions", {
+    method: "POST",
+    body
+  });
+  if (data.error) {
+    throw new BroadcastError(data.reason ?? data.error, {
+      reason: data.reason
+    });
+  }
+  const txid2 = typeof data === "string" ? data.replace(/"/g, "") : data.txid ?? getTransactionId(params.transaction);
+  return { txid: txid2 };
+}
+
+// src/actions/wallet/utils.ts
+function isProviderAccount(account) {
+  return account.type === "provider";
+}
+
+// src/actions/wallet/callContract.ts
+async function callContract(client, params) {
+  const account = client.account;
+  if (!account)
+    throw new Error("Account required");
+  if (isProviderAccount(account)) {
+    const result2 = await account.provider.request("stx_callContract", {
+      contract: params.contract,
+      functionName: params.functionName,
+      functionArgs: params.functionArgs ?? []
+    });
+    return result2.txid;
+  }
+  const [contractAddress, contractName] = parseContractId(params.contract);
+  const nonce = params.nonce ?? await getNonce(client, { address: account.address });
+  const unsigned = buildContractCall({
+    contractAddress,
+    contractName,
+    functionName: params.functionName,
+    functionArgs: params.functionArgs ?? [],
+    fee: params.fee ?? 0n,
+    nonce,
+    publicKey: account.publicKey,
+    chain: client.chain,
+    postConditionMode: params.postConditionMode,
+    postConditions: params.postConditions
+  });
+  if (params.fee === undefined) {
+    const estimates = await estimateFee(client, { transaction: unsigned });
+    const mid = estimates[1] ?? estimates[0];
+    if (mid) {
+      unsigned.auth.spendingCondition.fee = BigInt(mid.fee);
+    }
+  }
+  const signed = await signTransactionWithAccount(unsigned, account);
+  const result = await sendTransaction(client, { transaction: signed });
+  return result.txid;
+}
+
+// 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 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, maps };
+}
+function buildFunctionArgs(fn, args) {
+  return fn.args.map((arg) => {
+    const camelKey = toCamelCase(arg.name);
+    const hasOriginal = arg.name in args;
+    const hasCamel = camelKey in args;
+    const value = hasOriginal ? args[arg.name] : hasCamel ? args[camelKey] : undefined;
+    if (value === undefined)
+      throw new Error(`Missing argument: ${arg.name}`);
+    return jsToClarityValue(arg.type, value);
+  });
+}
+function isResponseOutput(type) {
+  return typeof type === "object" && type !== null && "response" in type;
+}
+function formatErrValue(value) {
+  if (typeof value === "bigint")
+    return value.toString();
+  if (typeof value === "string")
+    return `"${value}"`;
+  return String(value);
+}
+
+class ContractResponseError extends Error {
+  errorValue;
+  name = "ContractResponseError";
+  constructor(message, errorValue) {
+    super(message);
+    this.errorValue = errorValue;
+  }
+}
+// src/bns/abi.ts
+var BNS_ABI = {
+  functions: [
+    {
+      name: "get-owner-name",
+      access: "read-only",
+      args: [
+        { name: "name", type: { buff: { length: 48 } } },
+        { name: "namespace", type: { buff: { length: 20 } } }
+      ],
+      outputs: {
+        response: {
+          ok: { optional: "principal" },
+          error: "uint128"
+        }
+      }
+    },
+    {
+      name: "get-id-from-bns",
+      access: "read-only",
+      args: [
+        { name: "name", type: { buff: { length: 48 } } },
+        { name: "namespace", type: { buff: { length: 20 } } }
+      ],
+      outputs: { optional: "uint128" }
+    },
+    {
+      name: "get-bns-from-id",
+      access: "read-only",
+      args: [{ name: "id", type: "uint128" }],
+      outputs: {
+        optional: {
+          tuple: [
+            { name: "name", type: { buff: { length: 48 } } },
+            { name: "namespace", type: { buff: { length: 20 } } }
+          ]
+        }
+      }
+    },
+    {
+      name: "get-owner",
+      access: "read-only",
+      args: [{ name: "id", type: "uint128" }],
+      outputs: {
+        response: {
+          ok: { optional: "principal" },
+          error: "none"
+        }
+      }
+    },
+    {
+      name: "get-primary",
+      access: "read-only",
+      args: [{ name: "owner", type: "principal" }],
+      outputs: {
+        response: {
+          ok: {
+            optional: {
+              tuple: [
+                { name: "name", type: { buff: { length: 48 } } },
+                { name: "namespace", type: { buff: { length: 20 } } }
+              ]
+            }
+          },
+          error: "none"
+        }
+      }
+    },
+    {
+      name: "can-resolve-name",
+      access: "read-only",
+      args: [
+        { name: "namespace", type: { buff: { length: 20 } } },
+        { name: "name", type: { buff: { length: 48 } } }
+      ],
+      outputs: {
+        response: {
+          ok: {
+            tuple: [
+              { name: "renewal", type: "uint128" },
+              { name: "owner", type: "principal" }
+            ]
+          },
+          error: "uint128"
+        }
+      }
+    },
+    {
+      name: "get-renewal-height",
+      access: "read-only",
+      args: [{ name: "id", type: "uint128" }],
+      outputs: { response: { ok: "uint128", error: "uint128" } }
+    },
+    {
+      name: "get-name-price",
+      access: "read-only",
+      args: [
+        { name: "namespace", type: { buff: { length: 20 } } },
+        { name: "name", type: { buff: { length: 48 } } }
+      ],
+      outputs: {
+        response: {
+          ok: { response: { ok: "uint128", error: "uint128" } },
+          error: "uint128"
+        }
+      }
+    },
+    {
+      name: "get-bns-info",
+      access: "read-only",
+      args: [
+        { name: "name", type: { buff: { length: 48 } } },
+        { name: "namespace", type: { buff: { length: 20 } } }
+      ],
+      outputs: {
+        optional: {
+          tuple: [
+            {
+              name: "hashed-salted-fqn-preorder",
+              type: { optional: { buff: { length: 20 } } }
+            },
+            { name: "imported-at", type: { optional: "uint128" } },
+            { name: "owner", type: "principal" },
+            { name: "preordered-by", type: { optional: "principal" } },
+            { name: "registered-at", type: { optional: "uint128" } },
+            { name: "renewal-height", type: "uint128" },
+            { name: "stx-burn", type: "uint128" }
+          ]
+        }
+      }
+    },
+    {
+      name: "name-preorder",
+      access: "public",
+      args: [
+        { name: "hashed-salted-fqn", type: { buff: { length: 20 } } },
+        { name: "stx-to-burn", type: "uint128" }
+      ],
+      outputs: { response: { ok: "uint128", error: "uint128" } }
+    },
+    {
+      name: "name-register",
+      access: "public",
+      args: [
+        { name: "namespace", type: { buff: { length: 20 } } },
+        { name: "name", type: { buff: { length: 48 } } },
+        { name: "salt", type: { buff: { length: 20 } } }
+      ],
+      outputs: { response: { ok: "uint128", error: "uint128" } }
+    },
+    {
+      name: "name-claim-fast",
+      access: "public",
+      args: [
+        { name: "name", type: { buff: { length: 48 } } },
+        { name: "namespace", type: { buff: { length: 20 } } },
+        { name: "send-to", type: "principal" }
+      ],
+      outputs: { response: { ok: "uint128", error: "uint128" } }
+    },
+    {
+      name: "name-renewal",
+      access: "public",
+      args: [
+        { name: "namespace", type: { buff: { length: 20 } } },
+        { name: "name", type: { buff: { length: 48 } } }
+      ],
+      outputs: { response: { ok: "bool", error: "uint128" } }
+    },
+    {
+      name: "transfer",
+      access: "public",
+      args: [
+        { name: "id", type: "uint128" },
+        { name: "owner", type: "principal" },
+        { name: "recipient", type: "principal" }
+      ],
+      outputs: { response: { ok: "bool", error: "uint128" } }
+    },
+    {
+      name: "set-primary-name",
+      access: "public",
+      args: [{ name: "primary-name-id", type: "uint128" }],
+      outputs: { response: { ok: "bool", error: "uint128" } }
+    }
+  ],
+  non_fungible_tokens: [{ name: "BNS-V2", type: "uint128" }]
+};
+
+// src/bns/constants.ts
+var BNS_CONTRACTS = {
+  mainnet: {
+    address: "SP2QEZ06AGJ3RKJPBV14SY1V5BBFNAW33D96YPGZF",
+    name: "BNS-V2"
+  },
+  testnet: {
+    address: "ST2QEZ06AGJ3RKJPBV14SY1V5BBFNAW33D9SZJQ0M",
+    name: "BNS-V2"
+  }
+};
+var DEFAULT_NAMESPACE = "btc";
+
+// src/bns/utils.ts
+function parseFQN(fqn) {
+  const parts = fqn.split(".");
+  if (parts.length === 1) {
+    return {
+      name: parts[0],
+      namespace: DEFAULT_NAMESPACE
+    };
+  }
+  if (parts.length === 2) {
+    return {
+      name: parts[0],
+      namespace: parts[1]
+    };
+  }
+  throw new Error(`Invalid fully qualified name: ${fqn}. Expected format: "name.namespace" or "name"`);
+}
+function formatFQN(name, namespace) {
+  return `${name}.${namespace}`;
+}
+function validateName(name) {
+  if (name.length < 1 || name.length > 48)
+    return false;
+  const regex = /^[a-z0-9]([a-z0-9_-]*[a-z0-9])?$/;
+  return regex.test(name);
+}
+function validateNamespace(namespace) {
+  if (namespace.length < 1 || namespace.length > 20)
+    return false;
+  const regex = /^[a-z0-9]+$/;
+  return regex.test(namespace);
+}
+function validateFQN(fqn) {
+  try {
+    const { name, namespace } = parseFQN(fqn);
+    return validateName(name) && validateNamespace(namespace);
+  } catch {
+    return false;
+  }
+}
+
+// src/bns/actions.ts
+function getBnsContract(client) {
+  if (!client.chain) {
+    throw new Error("Client must have a chain configured");
+  }
+  const network = client.chain.network;
+  const contract = network === "mainnet" ? BNS_CONTRACTS.mainnet : BNS_CONTRACTS.testnet;
+  return getContract({
+    client,
+    address: contract.address,
+    name: contract.name,
+    abi: BNS_ABI
+  });
+}
+function stringToBytes(str) {
+  return new TextEncoder().encode(str);
+}
+async function resolveName(client, nameOrFQN) {
+  if (!validateFQN(nameOrFQN)) {
+    throw new Error(`Invalid name format: ${nameOrFQN}`);
+  }
+  const { name, namespace } = parseFQN(nameOrFQN);
+  const bns = getBnsContract(client);
+  try {
+    return await bns.read.getOwnerName({
+      name: stringToBytes(name),
+      namespace: stringToBytes(namespace)
+    });
+  } catch (e) {
+    if (e instanceof ContractResponseError)
+      return null;
+    throw e;
+  }
+}
+async function getPrimaryName(client, address) {
+  const bns = getBnsContract(client);
+  try {
+    const result = await bns.read.getPrimary({
+      owner: address
+    });
+    if (result === null)
+      return null;
+    const name = new TextDecoder().decode(result.name);
+    const namespace = new TextDecoder().decode(result.namespace);
+    return formatFQN(name, namespace);
+  } catch (e) {
+    if (e instanceof ContractResponseError)
+      return null;
+    throw e;
+  }
+}
+
+// src/chains/definitions.ts
+var mainnet = {
+  id: 1,
+  name: "Stacks Mainnet",
+  network: "mainnet",
+  transactionVersion: 0,
+  peerNetworkId: 385875968,
+  addressVersion: { singleSig: 22, multiSig: 20 },
+  magicBytes: "X2",
+  bootAddress: "SP000000000000000000002Q6VF78",
+  nativeCurrency: { name: "Stacks", symbol: "STX", decimals: 6 },
+  rpcUrls: {
+    default: {
+      http: ["https://api.mainnet.hiro.so"],
+      ws: ["wss://api.mainnet.hiro.so/extended/v1/ws"]
+    }
+  },
+  blockExplorers: {
+    default: { name: "Hiro Explorer", url: "https://explorer.hiro.so" }
+  }
+};
+var testnet = {
+  id: 2147483648,
+  name: "Stacks Testnet",
+  network: "testnet",
+  transactionVersion: 128,
+  peerNetworkId: 4278190080,
+  addressVersion: { singleSig: 26, multiSig: 21 },
+  magicBytes: "T2",
+  bootAddress: "ST000000000000000000002AMW42H",
+  nativeCurrency: { name: "Stacks", symbol: "STX", decimals: 6 },
+  rpcUrls: {
+    default: {
+      http: ["https://api.testnet.hiro.so"],
+      ws: ["wss://api.testnet.hiro.so/extended/v1/ws"]
+    }
+  },
+  blockExplorers: {
+    default: {
+      name: "Hiro Explorer",
+      url: "https://explorer.hiro.so/?chain=testnet"
+    }
+  }
+};
+var devnet = {
+  id: 2147483648,
+  name: "Stacks Devnet",
+  network: "testnet",
+  transactionVersion: 128,
+  peerNetworkId: 4278190080,
+  addressVersion: { singleSig: 26, multiSig: 21 },
+  magicBytes: "id",
+  bootAddress: "ST000000000000000000002AMW42H",
+  nativeCurrency: { name: "Stacks", symbol: "STX", decimals: 6 },
+  rpcUrls: {
+    default: {
+      http: ["http://localhost:3999"],
+      ws: ["ws://localhost:3999/extended/v1/ws"]
+    }
+  }
+};
+var mocknet = {
+  ...devnet,
+  name: "Stacks Mocknet",
+  addressVersion: { ...devnet.addressVersion }
+};
+
+// src/clients/createClient.ts
+var BASE_KEYS = new Set([
+  "chain",
+  "account",
+  "transport",
+  "request",
+  "extend"
+]);
+function bindExtend(base) {
+  return (fn) => {
+    const extensions = fn(base);
+    const next = { ...base };
+    for (const [key, value] of Object.entries(extensions)) {
+      if (BASE_KEYS.has(key))
+        continue;
+      next[key] = value;
+    }
+    next.extend = bindExtend(next);
+    return next;
+  };
+}
+function createClient(config) {
+  const transport = config.transport({ chain: config.chain });
+  const client = {
+    chain: config.chain,
+    account: config.account,
+    transport,
+    request: transport.request,
+    extend: null
+  };
+  client.extend = bindExtend(client);
+  return client;
+}
+
+// src/actions/public/getContractAbi.ts
+async function getContractAbi(client, params) {
+  const [address, name] = parseContractId(params.contract);
+  return client.request(`/v2/contracts/interface/${address}/${name}`, {
+    method: "GET"
+  });
+}
+
+// src/actions/public/multicall.ts
+async function multicall(client, params) {
+  const { calls, allowFailure = true } = params;
+  if (allowFailure) {
+    const settled = await Promise.allSettled(calls.map((call) => readContract(client, call)));
+    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 = await Promise.all(calls.map((call) => readContract(client, call)));
+  return results;
+}
+
+// src/errors/simulation.ts
+class SimulationError extends BaseError {
+  name = "SimulationError";
+  writesDetected;
+  constructor(message, options) {
+    super(message, { details: options.details });
+    this.writesDetected = options.writesDetected;
+  }
+}
+
+// src/actions/public/simulateCall.ts
+async function simulateCall(client, params) {
+  const [address, name] = parseContractId(params.contract);
+  const sender = params.sender ?? address;
+  const serializedArgs = (params.args ?? []).map((arg) => with0x(bytesToHex(serializeCVBytes(arg))));
+  let path = `/v2/contracts/call-read/${address}/${name}/${params.functionName}`;
+  if (params.tip) {
+    path += `?tip=${params.tip}`;
+  }
+  const data = await client.request(path, {
+    method: "POST",
+    body: {
+      sender,
+      arguments: serializedArgs
+    }
+  });
+  if (data.okay) {
+    return { success: true, result: deserializeCVBytes(data.result) };
+  }
+  const cause = data.cause ?? "Simulation failed";
+  const writesDetected = cause.includes("NotReadOnly") || cause.includes("CostBalanceExceeded");
+  return {
+    success: false,
+    error: new SimulationError(writesDetected ? "Function mutates state and cannot be simulated" : "Simulation failed", { writesDetected, details: cause })
+  };
+}
+
+// src/actions/public/simulateTransaction.ts
+function isMultiSig(hashMode) {
+  return hashMode === AddressHashMode.P2SH || hashMode === AddressHashMode.P2WSH || hashMode === AddressHashMode.P2SH_NonSequential || hashMode === AddressHashMode.P2WSH_P2SH_NonSequential;
+}
+function extractSender(tx, client) {
+  const { hashMode, signer } = tx.auth.spendingCondition;
+  const chain = client.chain;
+  const version = isMultiSig(hashMode) ? chain?.addressVersion.multiSig ?? 20 : chain?.addressVersion.singleSig ?? 22;
+  return c32address(version, signer);
+}
+async function simulateTransaction(client, params) {
+  const { transaction, tip } = params;
+  const { payload } = transaction;
+  if (payload.payloadType === PayloadType.ContractCall) {
+    const sender = params.sender ?? extractSender(transaction, client);
+    const contract = `${payload.contractAddress}.${payload.contractName}`;
+    const [execution, fees2] = await Promise.all([
+      simulateCall(client, {
+        contract,
+        functionName: payload.functionName,
+        args: payload.functionArgs,
+        sender,
+        tip
+      }),
+      estimateFee(client, { transaction })
+    ]);
+    return { type: "contract-call", execution, fees: fees2 };
+  }
+  const fees = await estimateFee(client, { transaction });
+  if (payload.payloadType === PayloadType.SmartContract || payload.payloadType === PayloadType.VersionedSmartContract) {
+    return { type: "contract-deploy", fees };
+  }
+  return { type: "token-transfer", fees };
+}
+
+// src/errors/websocket.ts
+class WebSocketError extends BaseError {
+  name = "WebSocketError";
+  constructor(message, options) {
+    super(message, options);
+  }
+}
+
+// src/subscriptions/actions.ts
+function getWsTransport(client) {
+  if (client.transport.type !== "webSocket") {
+    throw new WebSocketError("Watch actions require a webSocket transport. Use `webSocket()` when creating your client.");
+  }
+  return client.transport;
+}
+async function watchBlocks(client, params) {
+  const transport = getWsTransport(client);
+  return transport.subscribe({ event: "block" }, params.onBlock);
+}
+async function watchMempool(client, params) {
+  const transport = getWsTransport(client);
+  return transport.subscribe({ event: "mempool" }, params.onTransaction);
+}
+async function watchTransaction(client, params) {
+  const transport = getWsTransport(client);
+  return transport.subscribe({ event: "tx_update", tx_id: params.txId }, params.onUpdate);
+}
+async function watchAddress(client, params) {
+  const transport = getWsTransport(client);
+  return transport.subscribe({ event: "address_tx_update", address: params.address }, params.onTransaction);
+}
+async function watchAddressBalance(client, params) {
+  const transport = getWsTransport(client);
+  return transport.subscribe({ event: "address_balance_update", address: params.address }, params.onBalance);
+}
+async function watchNftEvent(client, params) {
+  const transport = getWsTransport(client);
+  let event;
+  if (params.assetIdentifier && params.value) {
+    event = "nft_event";
+  } else if (params.assetIdentifier) {
+    event = "nft_collection_event";
+  } else {
+    event = "nft_event";
+  }
+  return transport.subscribe({
+    event,
+    asset_identifier: params.assetIdentifier,
+    value: params.value
+  }, params.onEvent);
+}
+
+// src/clients/decorators/public.ts
+function publicActions(client) {
+  return {
+    getNonce: (params) => getNonce(client, params),
+    getBalance: (params) => getBalance(client, params),
+    getAccountInfo: (params) => getAccountInfo(client, params),
+    getBlock: (params) => getBlock(client, params),
+    getBlockHeight: () => getBlockHeight(client),
+    readContract: (params) => readContract(client, params),
+    getContractAbi: (params) => getContractAbi(client, params),
+    getMapEntry: (params) => getMapEntry(client, params),
+    estimateFee: (params) => estimateFee(client, params),
+    multicall: (params) => multicall(client, params),
+    simulateCall: (params) => simulateCall(client, params),
+    simulateTransaction: (params) => simulateTransaction(client, params),
+    watchBlocks: (params) => watchBlocks(client, params),
+    watchMempool: (params) => watchMempool(client, params),
+    watchTransaction: (params) => watchTransaction(client, params),
+    watchAddress: (params) => watchAddress(client, params),
+    watchAddressBalance: (params) => watchAddressBalance(client, params),
+    watchNftEvent: (params) => watchNftEvent(client, params)
+  };
+}
+
+// src/clients/createPublicClient.ts
+function createPublicClient(config) {
+  return createClient(config).extend(publicActions);
+}
+
+// src/transports/createTransport.ts
+function createTransport(type, config) {
+  return {
+    type,
+    request: config.request,
+    config
+  };
+}
+async function fetchWithRetry(url, options, retryCount, retryDelay, timeout) {
+  let lastError;
+  for (let attempt = 0;attempt <= retryCount; attempt++) {
+    try {
+      const controller = new AbortController;
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+      const response = await fetch(url, {
+        ...options,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (response.ok || response.status < 500) {
+        return response;
+      }
+      lastError = new Error(`HTTP ${response.status}: ${response.statusText}`);
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+    }
+    if (attempt < retryCount) {
+      await new Promise((r) => setTimeout(r, retryDelay * (attempt + 1)));
+    }
+  }
+  throw lastError ?? new Error("Request failed");
+}
+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);
+    }
+    const response = await fetchWithRetry(url, init, retryCount, retryDelay, timeout);
+    const contentType = response.headers.get("content-type") ?? "";
+    if (contentType.includes("application/json")) {
+      return response.json();
+    }
+    return response.text();
+  };
+}
+
+// src/transports/http.ts
+function http(url, config) {
+  return (params) => {
+    const resolvedUrl = url ?? params?.chain?.rpcUrls.default.http[0] ?? "http://localhost:3999";
+    const mergedConfig = {
+      ...config,
+      url: resolvedUrl
+    };
+    return createTransport("http", {
+      ...mergedConfig,
+      request: buildRequestFn(resolvedUrl, mergedConfig)
+    });
+  };
+}
+
+// src/tools/client.ts
+var _defaultClient = null;
+function getDefaultPublicClient() {
+  if (_defaultClient)
+    return _defaultClient;
+  const chain = process.env.STACKS_CHAIN === "testnet" ? testnet : mainnet;
+  _defaultClient = createPublicClient({
+    chain,
+    transport: http(process.env.STACKS_RPC_URL)
+  });
+  return _defaultClient;
+}
+
+// src/tools/index.ts
+var PRINCIPAL = z.string().describe("Stacks principal (SP…/SM… mainnet, ST… testnet)");
+async function stxBalance(client, principal) {
+  const balance = await getBalance(client, { address: principal });
+  return { microStx: balance.toString() };
+}
+async function accountInfo(client, principal) {
+  const info = await getAccountInfo(client, { address: principal });
+  return {
+    balance: info.balance.toString(),
+    nonce: info.nonce.toString()
+  };
+}
+async function block(client, args) {
+  return getBlock(client, args);
+}
+async function blockHeight(client) {
+  return { height: await getBlockHeight(client) };
+}
+async function contractRead(client, args) {
+  const result = await readContract(client, args);
+  return { result: JSON.stringify(result) };
+}
+async function fee(client, serializedTxHex) {
+  const raw = serializedTxHex.startsWith("0x") ? serializedTxHex.slice(2) : serializedTxHex;
+  const txBytes = new Uint8Array(Buffer.from(raw, "hex"));
+  const { deserializeTransaction } = await import("@stacks/transactions");
+  const transaction = deserializeTransaction(txBytes);
+  const fees = await estimateFee(client, {
+    transaction
+  });
+  return {
+    low: fees[0]?.fee ?? 0,
+    medium: fees[1]?.fee ?? 0,
+    high: fees[2]?.fee ?? 0
+  };
+}
+async function bnsResolveImpl(client, name) {
+  return { owner: await resolveName(client, name) };
+}
+async function bnsReverseImpl(client, principal) {
+  return { name: await getPrimaryName(client, principal) };
+}
+function hiroBase(client) {
+  const url = client.chain?.rpcUrls.default.http[0] ?? process.env.STACKS_RPC_URL ?? "https://api.hiro.so";
+  return url.replace(/\/$/, "");
+}
+async function hiroGet(client, path) {
+  const res = await fetch(`${hiroBase(client)}${path}`, {
+    headers: { Accept: "application/json" }
+  });
+  if (!res.ok) {
+    throw new Error(`Hiro API ${path} → ${res.status} ${res.statusText}`);
+  }
+  return res.json();
+}
+async function transactionByTxId(client, txId) {
+  const normalized = txId.startsWith("0x") ? txId : `0x${txId}`;
+  return hiroGet(client, `/extended/v1/tx/${normalized}`);
+}
+async function accountHistory(client, principal, limit) {
+  return hiroGet(client, `/extended/v2/addresses/${principal}/transactions?limit=${Math.min(limit, 50)}`);
+}
+async function mempoolStats(client) {
+  return hiroGet(client, "/extended/v1/tx/mempool/stats");
+}
+async function nftHoldings(client, principal, limit) {
+  return hiroGet(client, `/extended/v1/tokens/nft/holdings?principal=${encodeURIComponent(principal)}&limit=${Math.min(limit, 50)}`);
+}
+function createStacksTools(client) {
+  return {
+    getStxBalance: tool({
+      description: "Get the STX balance (in micro-STX) for a Stacks principal.",
+      inputSchema: z.object({ principal: PRINCIPAL }),
+      execute: ({ principal }) => stxBalance(client, principal)
+    }),
+    getAccountInfo: tool({
+      description: "Get account info (balance, locked, nonce) for a Stacks principal.",
+      inputSchema: z.object({ principal: PRINCIPAL }),
+      execute: ({ principal }) => accountInfo(client, principal)
+    }),
+    getBlock: tool({
+      description: "Fetch a Stacks block by height or hash. Omit both for the latest block.",
+      inputSchema: z.object({
+        height: z.number().int().nonnegative().optional(),
+        hash: z.string().optional()
+      }),
+      execute: (args) => block(client, args)
+    }),
+    getBlockHeight: tool({
+      description: "Get the current Stacks chain tip height.",
+      inputSchema: z.object({}),
+      execute: () => blockHeight(client)
+    }),
+    readContract: tool({
+      description: "Call a read-only Clarity function. Returns the decoded value as JSON.",
+      inputSchema: z.object({
+        contract: z.string().describe("Fully-qualified contract id: '{address}.{name}'"),
+        functionName: z.string(),
+        sender: PRINCIPAL.optional()
+      }),
+      execute: (args) => contractRead(client, args)
+    }),
+    estimateFee: tool({
+      description: "Estimate fee range (low / medium / high) for a serialized Stacks transaction.",
+      inputSchema: z.object({
+        serializedTxHex: z.string().describe("Hex-encoded serialized transaction")
+      }),
+      execute: ({ serializedTxHex }) => fee(client, serializedTxHex)
+    }),
+    bnsResolve: tool({
+      description: "Resolve a BNS name (e.g. 'satoshi.btc') to its owning Stacks principal.",
+      inputSchema: z.object({
+        name: z.string().describe("BNS name in 'name.namespace' form")
+      }),
+      execute: ({ name }) => bnsResolveImpl(client, name)
+    }),
+    bnsReverse: tool({
+      description: "Reverse-lookup the primary BNS name for a Stacks principal, if set.",
+      inputSchema: z.object({ principal: PRINCIPAL }),
+      execute: ({ principal }) => bnsReverseImpl(client, principal)
+    }),
+    getTransaction: tool({
+      description: "Fetch a confirmed Stacks transaction by txId (Hiro extended API).",
+      inputSchema: z.object({
+        txId: z.string().describe("Transaction id, with or without 0x prefix")
+      }),
+      execute: ({ txId }) => transactionByTxId(client, txId)
+    }),
+    getAccountHistory: tool({
+      description: "Paginated transaction history for a Stacks principal (Hiro extended API).",
+      inputSchema: z.object({
+        principal: PRINCIPAL,
+        limit: z.number().int().min(1).max(50).default(20)
+      }),
+      execute: ({ principal, limit }) => accountHistory(client, principal, limit)
+    }),
+    getMempoolStats: tool({
+      description: "Current mempool statistics: pending count, fee distribution, age buckets (Hiro extended API).",
+      inputSchema: z.object({}),
+      execute: () => mempoolStats(client)
+    }),
+    getNftHoldings: tool({
+      description: "NFT holdings for a Stacks principal across all collections (Hiro extended API).",
+      inputSchema: z.object({
+        principal: PRINCIPAL,
+        limit: z.number().int().min(1).max(50).default(20)
+      }),
+      execute: ({ principal, limit }) => nftHoldings(client, principal, limit)
+    })
+  };
+}
+var getStxBalance = tool({
+  description: "Get the STX balance (in micro-STX) for a Stacks principal. Uses default client.",
+  inputSchema: z.object({ principal: PRINCIPAL }),
+  execute: ({ principal }) => stxBalance(getDefaultPublicClient(), principal)
+});
+var getAccountInfo2 = tool({
+  description: "Get account info (balance, locked, nonce) for a Stacks principal.",
+  inputSchema: z.object({ principal: PRINCIPAL }),
+  execute: ({ principal }) => accountInfo(getDefaultPublicClient(), principal)
+});
+var getBlock2 = tool({
+  description: "Fetch a Stacks block by height or hash. Omit both for the latest block.",
+  inputSchema: z.object({
+    height: z.number().int().nonnegative().optional(),
+    hash: z.string().optional()
+  }),
+  execute: (args) => block(getDefaultPublicClient(), args)
+});
+var getBlockHeight2 = tool({
+  description: "Get the current Stacks chain tip height.",
+  inputSchema: z.object({}),
+  execute: () => blockHeight(getDefaultPublicClient())
+});
+var readContract2 = tool({
+  description: "Call a read-only Clarity function. Returns the decoded value as JSON.",
+  inputSchema: z.object({
+    contract: z.string(),
+    functionName: z.string(),
+    sender: PRINCIPAL.optional()
+  }),
+  execute: (args) => contractRead(getDefaultPublicClient(), args)
+});
+var estimateFee2 = tool({
+  description: "Estimate fee range (low / medium / high) for a serialized Stacks transaction.",
+  inputSchema: z.object({ serializedTxHex: z.string() }),
+  execute: ({ serializedTxHex }) => fee(getDefaultPublicClient(), serializedTxHex)
+});
+var bnsResolve = tool({
+  description: "Resolve a BNS name (e.g. 'satoshi.btc') to its owning Stacks principal.",
+  inputSchema: z.object({ name: z.string() }),
+  execute: ({ name }) => bnsResolveImpl(getDefaultPublicClient(), name)
+});
+var bnsReverse = tool({
+  description: "Reverse-lookup the primary BNS name for a Stacks principal, if set.",
+  inputSchema: z.object({ principal: PRINCIPAL }),
+  execute: ({ principal }) => bnsReverseImpl(getDefaultPublicClient(), principal)
+});
+var getTransaction = tool({
+  description: "Fetch a confirmed Stacks transaction by txId (Hiro extended API).",
+  inputSchema: z.object({ txId: z.string() }),
+  execute: ({ txId }) => transactionByTxId(getDefaultPublicClient(), txId)
+});
+var getAccountHistory = tool({
+  description: "Paginated transaction history for a Stacks principal (Hiro extended API).",
+  inputSchema: z.object({
+    principal: PRINCIPAL,
+    limit: z.number().int().min(1).max(50).default(20)
+  }),
+  execute: ({ principal, limit }) => accountHistory(getDefaultPublicClient(), principal, limit)
+});
+var getMempoolStats = tool({
+  description: "Current mempool statistics: pending count, fee distribution, age buckets (Hiro extended API).",
+  inputSchema: z.object({}),
+  execute: () => mempoolStats(getDefaultPublicClient())
+});
+var getNftHoldings = tool({
+  description: "NFT holdings for a Stacks principal across all collections (Hiro extended API).",
+  inputSchema: z.object({
+    principal: PRINCIPAL,
+    limit: z.number().int().min(1).max(50).default(20)
+  }),
+  execute: ({ principal, limit }) => nftHoldings(getDefaultPublicClient(), principal, limit)
+});
+export {
+  readContract2 as readContract,
+  getTransaction,
+  getStxBalance,
+  getNftHoldings,
+  getMempoolStats,
+  getBlockHeight2 as getBlockHeight,
+  getBlock2 as getBlock,
+  getAccountInfo2 as getAccountInfo,
+  getAccountHistory,
+  estimateFee2 as estimateFee,
+  createStacksTools,
+  bnsReverse,
+  bnsResolve
+};
+
+//# debugId=233963F854D70C5B64756E2164756E21
+//# sourceMappingURL=index.js.map