@secondlayer/stacks 4.3.1 → 5.0.0

package/dist/src/tools/index.cjs

@@ -59,8 +59,13 @@ var import_ai = require("ai");
 var import_zod = require("zod");
 
 // src/errors/base.ts
+function codeFromName(name) {
+  return name.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").toUpperCase();
+}
+
 class BaseError extends Error {
   name = "StacksError";
+  #code;
   shortMessage;
   details;
   constructor(shortMessage, options) {
@@ -70,12 +75,21 @@ class BaseError extends Error {
 ${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,
@@ -414,7 +428,7 @@ function serializeCVBytes(value) {
       return withTypeId(value.type, concatBytes(...parts));
     }
     case "tuple": {
-      const keys = Object.keys(value.value).sort((a, b) => a.localeCompare(b));
+      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));
@@ -728,14 +742,12 @@ async function estimateFee(client, params) {
 // src/actions/public/getAccountHistory.ts
 async function getAccountHistory(client, params) {
   const limit = Math.min(params.limit ?? 20, 50);
-  return client.request(`/extended/v2/addresses/${params.address}/transactions?limit=${limit}`, { method: "GET" });
+  return client.request(`/extended/v2/addresses/${encodeURIComponent(params.address)}/transactions?limit=${limit}`, { method: "GET" });
 }
 
 // src/actions/public/getAccountInfo.ts
 async function getAccountInfo(client, params) {
-  const data = await client.request(`/v2/accounts/${params.address}?proof=1`, {
-    method: "GET"
-  });
+  const data = await client.request(`/v2/accounts/${encodeURIComponent(params.address)}?proof=1`, { method: "GET" });
   const balance = data?.balance;
   const nonce = data?.nonce;
   if (typeof balance !== "string" && typeof balance !== "number" || typeof nonce !== "string" && typeof nonce !== "number") {
@@ -751,7 +763,7 @@ async function getAccountInfo(client, params) {
 
 // src/actions/public/getBalance.ts
 async function getBalance(client, params) {
-  const data = await client.request(`/v2/accounts/${params.address}`, {
+  const data = await client.request(`/v2/accounts/${encodeURIComponent(params.address)}`, {
     method: "GET"
   });
   const balance = data?.balance;
@@ -764,16 +776,16 @@ async function getBalance(client, params) {
 // src/actions/public/getBlock.ts
 async function getBlock(client, params) {
   if (params?.hash) {
-    return client.request(`/extended/v2/blocks/${params.hash}`, {
-      method: "GET"
-    });
+    return client.request(`/extended/v2/blocks/${encodeURIComponent(params.hash)}`, { method: "GET" });
   }
   if (params?.height !== undefined) {
-    return client.request(`/extended/v2/blocks/${params.height}`, {
-      method: "GET"
-    });
+    return client.request(`/extended/v2/blocks/${encodeURIComponent(String(params.height))}`, { method: "GET" });
   }
-  return client.request("/extended/v2/blocks?limit=1", { method: "GET" });
+  const data = await client.request("/extended/v2/blocks?limit=1", {
+    method: "GET"
+  });
+  const results = data?.results;
+  return Array.isArray(results) ? results[0] ?? null : data;
 }
 
 // src/actions/public/getBlockHeight.ts
@@ -796,6 +808,51 @@ async function getNftHoldings(client, params) {
   return client.request(`/extended/v1/tokens/nft/holdings?principal=${encodeURIComponent(params.address)}&limit=${limit}`, { method: "GET" });
 }
 
+// src/errors/transaction.ts
+class BroadcastError extends BaseError {
+  name = "BroadcastError";
+  txid;
+  reason;
+  reasonData;
+  constructor(message, options) {
+    super(message, options);
+    this.txid = options?.txid;
+    this.reason = options?.reason;
+    this.reasonData = options?.reasonData;
+  }
+}
+
+class TransactionAbortedError extends BaseError {
+  name = "TransactionAbortedError";
+  receipt;
+  constructor(message, options) {
+    super(message, options);
+    this.receipt = options.receipt;
+  }
+}
+
+class TransactionDroppedError extends BaseError {
+  name = "TransactionDroppedError";
+  txid;
+  constructor(message, options) {
+    super(message, options);
+    this.txid = options.txid;
+  }
+}
+
+class WaitForTransactionTimeoutError extends BaseError {
+  name = "WaitForTransactionTimeoutError";
+  txid;
+  constructor(message, options) {
+    super(message, options);
+    this.txid = options.txid;
+  }
+}
+
+class SerializationError extends BaseError {
+  name = "SerializationError";
+}
+
 // src/utils/bytes-reader.ts
 class BytesReader {
   data;
@@ -803,23 +860,32 @@ class BytesReader {
   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) {
-    if (this.offset + length > this.data.length) {
-      throw new Error(`Buffer underflow: need ${length} bytes at offset ${this.offset}, have ${this.data.length}`);
-    }
+    this.ensure(length);
     const slice = this.data.slice(this.offset, this.offset + length);
     this.offset += length;
     return slice;
@@ -861,11 +927,33 @@ function publicKeyToAddress(publicKey, network = "mainnet") {
   const version = network === "mainnet" ? AddressVersion.MainnetSingleSig : AddressVersion.TestnetSingleSig;
   return c32address(version, bytesToHex(hash160(bytes)));
 }
+var CONTRACT_NAME_REGEX = /^[a-zA-Z][a-zA-Z0-9_-]{0,127}$/;
+function validateStacksAddress(address) {
+  try {
+    c32addressDecode(address);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function parsePrincipal(value) {
+  const parts = value.split(".");
+  if (parts.length > 2)
+    return null;
+  const [address, contractName] = parts;
+  if (!validateStacksAddress(address))
+    return null;
+  if (contractName === undefined)
+    return { address };
+  if (!CONTRACT_NAME_REGEX.test(contractName))
+    return null;
+  return { address, contractName };
+}
 function parseContractId(contractId) {
-  const [address, name] = contractId.split(".");
-  if (!address || !name)
+  const parsed = parsePrincipal(contractId);
+  if (!parsed?.contractName)
     throw new Error(`Invalid contract identifier: ${contractId}`);
-  return [address, name];
+  return [parsed.address, parsed.contractName];
 }
 function isClarityName(name) {
   const regex = /^[a-zA-Z]([a-zA-Z0-9]|[-_!?+<>=/*])*$|^[-+=/*]$|^[<>]=?$/;
@@ -954,10 +1042,10 @@ var Cl = {
   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);
+    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);
@@ -995,7 +1083,18 @@ function readLPString(reader, prefixBytes = 1) {
   }
   return bytesToUtf8(reader.readBytes(length));
 }
-function readCV(reader) {
+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) {
@@ -1014,11 +1113,11 @@ function readCV(reader) {
     case "none":
       return noneCV();
     case "some":
-      return someCV(readCV(reader));
+      return someCV(readCV(reader, depth + 1));
     case "ok":
-      return responseOkCV(readCV(reader));
+      return responseOkCV(readCV(reader, depth + 1));
     case "err":
-      return responseErrorCV(readCV(reader));
+      return responseErrorCV(readCV(reader, depth + 1));
     case "address":
       return standardPrincipalCV(readAddress(reader));
     case "contract": {
@@ -1028,18 +1127,20 @@ function readCV(reader) {
     }
     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));
+        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);
+        data[key] = readCV(reader, depth + 1);
       }
       return tupleCV(data);
     }
@@ -1052,7 +1153,7 @@ function readCV(reader) {
       return stringUtf8CV(bytesToUtf8(reader.readBytes(len)));
     }
     default:
-      throw new Error(`Cannot deserialize unknown clarity type: ${type}`);
+      throw new SerializationError(`Cannot deserialize unknown clarity type: ${type}`);
   }
 }
 function deserializeCVBytes(input) {
@@ -1064,12 +1165,209 @@ function deserializeCVBytes(input) {
 class HttpRequestError extends BaseError {
   name = "HttpRequestError";
   status;
+  url;
+  method;
   constructor(status, options) {
-    super(`HTTP request failed with status ${status}`, options);
+    const where = options?.url !== undefined ? ` (${options.method ?? "GET"} ${options.url})` : "";
+    super(`HTTP request failed with status ${status}${where}`, options);
     this.status = status;
+    this.url = options?.url;
+    this.method = options?.method;
   }
 }
 
+// src/errors/transport.ts
+class TimeoutError extends BaseError {
+  name = "TimeoutError";
+  method;
+  url;
+  timeout;
+  attempt;
+  constructor(params) {
+    super(`${params.method} ${params.url} did not complete within ${params.timeout}ms (attempt ${params.attempt + 1})`);
+    this.method = params.method;
+    this.url = params.url;
+    this.timeout = params.timeout;
+    this.attempt = params.attempt;
+  }
+}
+
+// src/transports/createTransport.ts
+function createTransport(type, config) {
+  const { request, apiKey: _apiKey, ...exposed } = config;
+  return {
+    type,
+    request,
+    config: exposed
+  };
+}
+var MAX_ERROR_DETAILS_BYTES = 4096;
+function capDetails(body) {
+  if (body === undefined)
+    return;
+  const bytes = new TextEncoder().encode(body);
+  if (bytes.length <= MAX_ERROR_DETAILS_BYTES)
+    return body;
+  const head = new TextDecoder().decode(bytes.subarray(0, MAX_ERROR_DETAILS_BYTES));
+  return `${head}... [truncated ${bytes.length - MAX_ERROR_DETAILS_BYTES} bytes]`;
+}
+function isRetryableStatus(status) {
+  return status === 429 || status >= 500;
+}
+var MAX_RETRY_AFTER_MS = 60000;
+function retryAfterMs(response) {
+  const value = response.headers.get("Retry-After");
+  if (!value)
+    return;
+  const seconds = Number(value);
+  const ms = Number.isFinite(seconds) ? seconds * 1000 : Date.parse(value) - Date.now();
+  if (!Number.isFinite(ms) || ms < 0 || ms > MAX_RETRY_AFTER_MS)
+    return;
+  return ms;
+}
+function abortReason(signal) {
+  const reason = signal.reason;
+  if (reason instanceof Error)
+    return reason;
+  return new DOMException(typeof reason === "string" ? reason : "The operation was aborted", "AbortError");
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted)
+      return reject(abortReason(signal));
+    const onAbort = () => {
+      clearTimeout(id);
+      reject(abortReason(signal));
+    };
+    const id = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function fetchWithRetry(url, options, retryCount, retryDelay, timeout, extra = {}) {
+  const { signal } = extra;
+  const read = extra.read ?? (async (response) => response);
+  const method = options.method ?? "GET";
+  let lastError;
+  for (let attempt = 0;attempt <= retryCount; attempt++) {
+    if (signal?.aborted)
+      throw abortReason(signal);
+    const controller = new AbortController;
+    let timedOut = false;
+    const timeoutId = setTimeout(() => {
+      timedOut = true;
+      controller.abort(new TimeoutError({ method, url, timeout, attempt }));
+    }, timeout);
+    const onCallerAbort = () => controller.abort(abortReason(signal));
+    signal?.addEventListener("abort", onCallerAbort, { once: true });
+    const aborted = new Promise((_, reject) => {
+      if (controller.signal.aborted)
+        return reject(controller.signal.reason);
+      controller.signal.addEventListener("abort", () => reject(controller.signal.reason), { once: true });
+    });
+    let response;
+    try {
+      try {
+        response = await Promise.race([
+          fetch(url, { ...options, signal: controller.signal }),
+          aborted
+        ]);
+      } catch (error) {
+        if (signal?.aborted)
+          throw abortReason(signal);
+        lastError = timedOut ? new TimeoutError({ method, url, timeout, attempt }) : error instanceof Error ? error : new Error(String(error));
+        if (attempt < retryCount) {
+          clearTimeout(timeoutId);
+          await sleep(retryDelay * (attempt + 1), signal);
+          continue;
+        }
+        throw lastError;
+      }
+      if (response.ok) {
+        try {
+          return await Promise.race([read(response), aborted]);
+        } catch (error) {
+          response.body?.cancel().catch(() => {});
+          if (signal?.aborted)
+            throw abortReason(signal);
+          if (!timedOut)
+            throw error;
+          lastError = new TimeoutError({ method, url, timeout, attempt });
+          if (attempt < retryCount) {
+            clearTimeout(timeoutId);
+            await sleep(retryDelay * (attempt + 1), signal);
+            continue;
+          }
+          throw lastError;
+        }
+      }
+      const retryable = isRetryableStatus(response.status);
+      if (!retryable || attempt === retryCount) {
+        const body = await Promise.race([
+          response.text().catch(() => {
+            return;
+          }),
+          aborted.catch(() => {
+            return;
+          })
+        ]);
+        throw new HttpRequestError(response.status, {
+          details: capDetails(body),
+          url,
+          method
+        });
+      }
+      lastError = new HttpRequestError(response.status, { url, method });
+      const delay = retryAfterMs(response) ?? retryDelay * (attempt + 1);
+      response.body?.cancel().catch(() => {});
+      clearTimeout(timeoutId);
+      await sleep(delay, signal);
+    } finally {
+      clearTimeout(timeoutId);
+      signal?.removeEventListener("abort", onCallerAbort);
+    }
+  }
+  throw lastError ?? new Error("Request failed");
+}
+async function readBody(response) {
+  const contentType = response.headers.get("content-type") ?? "";
+  if (contentType.includes("application/json")) {
+    return response.json();
+  }
+  return response.text();
+}
+function buildRequestFn(baseUrl, config) {
+  const {
+    timeout = 30000,
+    retryCount = 3,
+    retryDelay = 150,
+    fetchOptions = {},
+    apiKey
+  } = config;
+  return async (path, options) => {
+    const url = `${baseUrl.replace(/\/$/, "")}${path}`;
+    const headers = {
+      "Content-Type": "application/json",
+      ...fetchOptions.headers,
+      ...options?.headers
+    };
+    if (apiKey) {
+      headers["x-api-key"] = apiKey;
+    }
+    const init = {
+      ...fetchOptions,
+      method: options?.method ?? "GET",
+      headers
+    };
+    if (options?.body !== undefined) {
+      init.body = JSON.stringify(options.body);
+    }
+    return fetchWithRetry(url, init, options?.retryCount ?? retryCount, retryDelay, timeout, { signal: options?.signal, read: readBody });
+  };
+}
+
 // src/actions/public/txSources.ts
 function normalizeTxid(txid) {
   return txid.startsWith("0x") ? txid : `0x${txid}`;
@@ -1099,9 +1397,7 @@ function extendedApiSource() {
     async get({ client, txid }) {
       let data;
       try {
-        data = await client.request(`/extended/v1/tx/${normalizeTxid(txid)}`, {
-          method: "GET"
-        });
+        data = await client.request(`/extended/v1/tx/${encodeURIComponent(normalizeTxid(txid))}`, { method: "GET" });
       } catch (error) {
         if (error instanceof HttpRequestError && error.status === 404) {
           return { receipt: null };
@@ -1141,8 +1437,8 @@ 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/${address}/${name}/${params.functionName}`;
-  const data = await client.request(params.tip ? `${path}?tip=${params.tip}` : path, {
+  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,
@@ -1155,6 +1451,50 @@ async function readContract(client, params) {
   throw new Error(data.cause ?? "Read-only call failed");
 }
 
+// src/actions/wallet/utils.ts
+function isProviderAccount(account) {
+  return account.type === "provider";
+}
+var FEE_TIERS = ["min", "low", "mid", "high"];
+var TIER_INDEX = { low: 0, mid: 1, high: 2 };
+function isFeeTier(fee) {
+  return typeof fee === "string" && FEE_TIERS.includes(fee);
+}
+function minimumFee(transaction) {
+  return BigInt(serializeTransaction(transaction).length);
+}
+function isNoEstimateAvailable(error) {
+  return error instanceof HttpRequestError && error.status === 400 && (error.details?.includes("NoEstimateAvailable") ?? false);
+}
+async function resolveFee(client, transaction, fee) {
+  if (fee !== undefined && !isFeeTier(fee))
+    return { fee: intToBigInt(fee) };
+  const tier = fee ?? "mid";
+  if (tier === "min")
+    return { fee: minimumFee(transaction), tier };
+  let estimates;
+  try {
+    estimates = await estimateFee(client, { transaction });
+  } catch (error) {
+    if (!isNoEstimateAvailable(error))
+      throw error;
+    return { fee: minimumFee(transaction), tier: "min" };
+  }
+  const pick = estimates[TIER_INDEX[tier]] ?? estimates[estimates.length - 1];
+  if (pick)
+    return { fee: BigInt(pick.fee), tier };
+  return { fee: minimumFee(transaction), tier: "min" };
+}
+function setUnsignedFee(transaction, fee) {
+  transaction.auth.spendingCondition.fee = fee;
+  clearTxCache(transaction);
+}
+function assertNoFeeTierForProvider(fee) {
+  if (isFeeTier(fee)) {
+    throw new Error(`Fee tier '${fee}' requires local signing; provider (wallet) accounts set their own fee`);
+  }
+}
+
 // src/clarity/abi/utils.ts
 function toCamelCase(str) {
   return str.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase()).replace(/-([A-Z])/g, (_, letter) => letter).replace(/-(\d)/g, (_, digit) => digit).replace(/-/g, "").replace(/^\d/, "_$&");
@@ -1959,6 +2299,18 @@ async function getMapEntry(client, params) {
   return deserializeCVBytes(data.data);
 }
 
+// src/actions/public/getNonce.ts
+async function getNonce(client, params) {
+  const data = await client.request(`/v2/accounts/${params.address}`, {
+    method: "GET"
+  });
+  const nonce = data?.nonce;
+  if (typeof nonce !== "number" && typeof nonce !== "string") {
+    throw new Error(`getNonce: unexpected /v2/accounts response for ${params.address} (missing numeric nonce)`);
+  }
+  return BigInt(nonce);
+}
+
 // src/transactions/signer.ts
 function txid(tx) {
   return txidFromBytes(serializeTransaction(tx));
@@ -1991,70 +2343,17 @@ function getTransactionId(tx) {
   return txid(tx);
 }
 
-// src/errors/transaction.ts
-class BroadcastError extends BaseError {
-  name = "BroadcastError";
-  txid;
-  reason;
-  reasonData;
-  constructor(message, options) {
-    super(message, options);
-    this.txid = options?.txid;
-    this.reason = options?.reason;
-    this.reasonData = options?.reasonData;
-  }
-}
-
-class TransactionAbortedError extends BaseError {
-  name = "TransactionAbortedError";
-  receipt;
-  constructor(message, options) {
-    super(message, options);
-    this.receipt = options.receipt;
-  }
-}
-
-class TransactionDroppedError extends BaseError {
-  name = "TransactionDroppedError";
-  txid;
-  constructor(message, options) {
-    super(message, options);
-    this.txid = options.txid;
-  }
-}
-
-class WaitForTransactionTimeoutError extends BaseError {
-  name = "WaitForTransactionTimeoutError";
-  txid;
-  constructor(message, options) {
-    super(message, options);
-    this.txid = options.txid;
-  }
-}
-
-// src/actions/public/getNonce.ts
-async function getNonce(client, params) {
-  const data = await client.request(`/v2/accounts/${params.address}`, {
-    method: "GET"
-  });
-  const nonce = data?.nonce;
-  if (typeof nonce !== "number" && typeof nonce !== "string") {
-    throw new Error(`getNonce: unexpected /v2/accounts response for ${params.address} (missing numeric nonce)`);
-  }
-  return BigInt(nonce);
-}
-
 // src/actions/public/waitForTransactionReceipt.ts
-var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
 async function waitForTransactionReceipt(client, params) {
   const {
     txid: txid2,
     confirmations = 1,
     timeout = 180000,
-    pollingInterval = 3000,
-    droppedGracePeriod = 30000
+    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;
@@ -2092,7 +2391,7 @@ async function waitForTransactionReceipt(client, params) {
     if (Date.now() - startedAt >= timeout) {
       throw new WaitForTransactionTimeoutError(`Timed out after ${timeout}ms waiting for transaction ${txid2}`, { txid: txid2 });
     }
-    await sleep(pollingInterval);
+    await sleep2(pollingInterval);
   }
 }
 
@@ -2105,7 +2404,11 @@ async function sendTransaction(client, params) {
   }
   let data;
   try {
-    data = await client.request("/v2/transactions", { method: "POST", body });
+    data = await client.request("/v2/transactions", {
+      method: "POST",
+      body,
+      retryCount: 0
+    });
   } catch (error) {
     if (error instanceof HttpRequestError && error.details) {
       try {
@@ -2113,6 +2416,12 @@ async function sendTransaction(client, params) {
       } 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;
     }
@@ -2142,6 +2451,13 @@ async function resolveNonce(client, address) {
     return client.nonceManager.consume({ client, address });
   return getNonce(client, { address });
 }
+async function releaseNonce(client, address, nonce) {
+  if (!client.nonceManager)
+    return;
+  try {
+    await client.nonceManager.release({ client, address, nonce });
+  } catch {}
+}
 function isNonceConflictError(error) {
   if (!(error instanceof BroadcastError))
     return false;
@@ -2166,42 +2482,6 @@ async function broadcastWithNonceReset(client, params) {
   }
 }
 
-// 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);
-}
-async function resolveFee(client, transaction, fee) {
-  if (fee !== undefined && !isFeeTier(fee))
-    return intToBigInt(fee);
-  const tier = fee ?? "mid";
-  if (tier === "min")
-    return minimumFee(transaction);
-  try {
-    const estimates = await estimateFee(client, { transaction });
-    const pick = estimates[TIER_INDEX[tier]] ?? estimates[estimates.length - 1];
-    if (pick)
-      return BigInt(pick.fee);
-  } catch {}
-  return minimumFee(transaction);
-}
-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;
@@ -2217,28 +2497,36 @@ async function callContract(client, params) {
     });
     return result.txid;
   }
+  const managed = params.nonce === undefined && client.nonceManager !== undefined;
   const nonce = params.nonce ?? await resolveNonce(client, account.address);
-  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) {
-    setUnsignedFee(unsigned, await resolveFee(client, unsigned, params.fee));
+  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;
   }
-  const signed = await signTransactionWithAccount(unsigned, account);
-  return broadcastWithNonceReset(client, {
-    transaction: signed,
-    address: account.address
-  });
 }
 
 // src/actions/getContract.ts
@@ -2318,7 +2606,9 @@ function getContract(params) {
         }
         const functionArgs = buildFunctionArgs(fn, args);
         const network = client.chain?.network ?? "mainnet";
-        const nonce = options?.nonce ?? await resolveNonce(client, publicKeyToAddress(publicKey, network));
+        const nonce = options?.nonce ?? await getNonce(client, {
+          address: publicKeyToAddress(publicKey, network)
+        });
         const unsigned = buildContractCall({
           contractAddress: address,
           contractName,
@@ -2333,13 +2623,8 @@ function getContract(params) {
           sponsored: options?.sponsored
         });
         if (options?.fee === undefined) {
-          const estimates = await estimateFee(client, {
-            transaction: unsigned
-          });
-          const mid = estimates[1] ?? estimates[0];
-          if (mid) {
-            setUnsignedFee(unsigned, BigInt(mid.fee));
-          }
+          const { fee } = await resolveFee(client, unsigned, undefined);
+          setUnsignedFee(unsigned, fee);
         }
         return unsigned;
       };
@@ -2415,6 +2700,56 @@ var SIP018_PREFIX = new Uint8Array([
   49,
   56
 ]);
+// src/clarity/prettyPrint.ts
+function cvToJSON(val) {
+  switch (val.type) {
+    case "true":
+      return { type: "bool", value: true };
+    case "false":
+      return { type: "bool", value: false };
+    case "int":
+      return { type: "int", value: val.value.toString() };
+    case "uint":
+      return { type: "uint", value: val.value.toString() };
+    case "buffer": {
+      const hex = without0x(val.value);
+      return {
+        type: `(buff ${Math.ceil(hex.length / 2)})`,
+        value: `0x${hex}`
+      };
+    }
+    case "none":
+      return { type: "(optional none)", value: null };
+    case "some":
+      return { type: "(optional)", value: cvToJSON(val.value) };
+    case "ok":
+      return { type: "(response)", value: cvToJSON(val.value), success: true };
+    case "err":
+      return { type: "(response)", value: cvToJSON(val.value), success: false };
+    case "address":
+    case "contract":
+      return { type: "principal", value: val.value };
+    case "list":
+      return { type: "(list)", value: val.value.map(cvToJSON) };
+    case "tuple": {
+      const result = {};
+      for (const key of Object.keys(val.value)) {
+        result[key] = cvToJSON(val.value[key]);
+      }
+      return { type: "(tuple)", value: result };
+    }
+    case "ascii":
+      return {
+        type: `(string-ascii ${asciiToBytes(val.value).length})`,
+        value: val.value
+      };
+    case "utf8":
+      return {
+        type: `(string-utf8 ${utf8ToBytes(val.value).length})`,
+        value: val.value
+      };
+  }
+}
 // src/clarity/abi/standards.ts
 var SIP010_ABI = {
   functions: [
@@ -3101,16 +3436,44 @@ async function getRawBlock(client, params) {
 }
 
 // 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 } = 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) {
-    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)));
+  const results = [];
+  for (const r of settled) {
+    if (r.status === "rejected")
+      throw r.reason;
+    results.push(r.value);
+  }
   return results;
 }
 
@@ -3272,100 +3635,6 @@ function createPublicClient(config) {
   return createClient(config).extend(publicActions);
 }
 
-// src/transports/createTransport.ts
-function createTransport(type, config) {
-  return {
-    type,
-    request: config.request,
-    config
-  };
-}
-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;
-}
-async function fetchWithRetry(url, options, retryCount, retryDelay, timeout) {
-  let lastError;
-  for (let attempt = 0;attempt <= retryCount; attempt++) {
-    let response;
-    try {
-      const controller = new AbortController;
-      const timeoutId = setTimeout(() => controller.abort(), timeout);
-      response = await fetch(url, {
-        ...options,
-        signal: controller.signal
-      });
-      clearTimeout(timeoutId);
-    } catch (error) {
-      lastError = error instanceof Error ? error : new Error(String(error));
-      if (attempt < retryCount) {
-        await new Promise((r) => setTimeout(r, retryDelay * (attempt + 1)));
-        continue;
-      }
-      throw lastError;
-    }
-    if (response.ok) {
-      return response;
-    }
-    const retryable = isRetryableStatus(response.status);
-    if (!retryable || attempt === retryCount) {
-      throw new HttpRequestError(response.status, {
-        details: await response.text().catch(() => {
-          return;
-        })
-      });
-    }
-    lastError = new HttpRequestError(response.status);
-    const delay = retryAfterMs(response) ?? retryDelay * (attempt + 1);
-    await new Promise((r) => setTimeout(r, delay));
-  }
-  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) => {
@@ -3386,36 +3655,47 @@ var _defaultClient = null;
 function getDefaultPublicClient() {
   if (_defaultClient)
     return _defaultClient;
-  const chain = process.env.STACKS_CHAIN === "testnet" ? testnet : mainnet;
+  const network = process.env.STACKS_NETWORK ?? process.env.STACKS_CHAIN;
+  const chain = network === "testnet" ? testnet : mainnet;
+  const url = process.env.STACKS_NODE_RPC_URL ?? process.env.SL_API_URL ?? process.env.STACKS_RPC_URL;
   _defaultClient = createPublicClient({
     chain,
-    transport: http(process.env.STACKS_RPC_URL)
+    transport: http(url)
   });
   return _defaultClient;
 }
 
 // src/tools/index.ts
-var PRINCIPAL = import_zod.z.string().describe("Stacks principal (SP…/SM… mainnet, ST… testnet)");
-async function stxBalance(client, principal) {
-  const balance = await getBalance(client, { address: principal });
+var PRINCIPAL = import_zod.z.string().refine((v) => parsePrincipal(v) !== null, {
+  message: "Expected a Stacks principal: a c32 address (SP…/SM… mainnet, ST… testnet), optionally followed by .contract-name"
+}).describe("Stacks principal (SP…/SM… mainnet, ST… testnet)");
+var CONTRACT_ID = import_zod.z.string().refine((v) => parsePrincipal(v)?.contractName !== undefined, {
+  message: "Expected a contract id in '{address}.{name}' form"
+}).describe("Fully-qualified contract id: '{address}.{name}'");
+var FUNCTION_NAME = import_zod.z.string().refine(isClarityName, { message: "Expected a Clarity function name" });
+var HASH_32 = /^(0x)?[0-9a-fA-F]{64}$/;
+var TX_ID = import_zod.z.string().regex(HASH_32, "Expected a 32-byte hex transaction id").describe("Transaction id, with or without 0x prefix");
+var BLOCK_HASH = import_zod.z.string().regex(HASH_32, "Expected a 32-byte hex block hash");
+async function stxBalance(resolve, principal) {
+  const balance = await getBalance(resolve(), { address: principal });
   return { microStx: balance.toString() };
 }
-async function accountInfo(client, principal) {
-  const info = await getAccountInfo(client, { address: principal });
+async function accountInfo(resolve, principal) {
+  const info = await getAccountInfo(resolve(), { address: principal });
   return {
     balance: info.balance.toString(),
     nonce: info.nonce.toString()
   };
 }
-async function block(client, args) {
-  return getBlock(client, args);
+async function block(resolve, args) {
+  return getBlock(resolve(), args);
 }
-async function blockHeight(client) {
-  return { height: await getBlockHeight(client) };
+async function blockHeight(resolve) {
+  return { height: await getBlockHeight(resolve()) };
 }
-async function contractRead(client, args) {
-  const result = await readContract(client, args);
-  return { result: JSON.stringify(result) };
+async function contractRead(resolve, args) {
+  const result = await readContract(resolve(), args);
+  return { result: cvToJSON(result) };
 }
 function assertValidHex(raw) {
   if (raw.length % 2 !== 0) {
@@ -3425,199 +3705,156 @@ function assertValidHex(raw) {
     throw new Error("serializedTxHex: contains non-hex characters");
   }
 }
-async function fee(client, serializedTxHex) {
+async function fee(resolve, serializedTxHex) {
   const raw = serializedTxHex.startsWith("0x") ? serializedTxHex.slice(2) : serializedTxHex;
   assertValidHex(raw);
-  const txBytes = new Uint8Array(Buffer.from(raw, "hex"));
+  const txBytes = hexToBytes(raw);
   let transaction;
   try {
     transaction = deserializeTransaction(txBytes);
   } catch (e) {
-    throw new Error(`serializedTxHex: deserialization failed — ${e instanceof Error ? e.message : String(e)}`);
+    throw new Error(`serializedTxHex: deserialization failed: ${e instanceof Error ? e.message : String(e)}`);
   }
-  const fees = await estimateFee(client, {
-    transaction
-  });
+  const fees = await estimateFee(resolve(), { transaction });
+  if (fees.length === 0) {
+    const min = Number(minimumFee(transaction));
+    return {
+      low: min,
+      medium: min,
+      high: min,
+      source: "min",
+      tiers: 0
+    };
+  }
+  const low = fees[0]?.fee ?? 0;
   return {
-    low: fees[0]?.fee ?? 0,
-    medium: fees[1]?.fee ?? 0,
-    high: fees[2]?.fee ?? 0
+    low,
+    medium: fees[1]?.fee ?? low,
+    high: fees[2]?.fee ?? fees[1]?.fee ?? low,
+    source: "node",
+    tiers: fees.length
   };
 }
-async function bnsResolveImpl(client, name) {
-  return { owner: await resolveName(client, name) };
+async function bnsResolveImpl(resolve, name) {
+  return { owner: await resolveName(resolve(), name) };
 }
-async function bnsReverseImpl(client, principal) {
-  return { name: await getPrimaryName(client, principal) };
+async function bnsReverseImpl(resolve, principal) {
+  return { name: await getPrimaryName(resolve(), principal) };
 }
-async function transactionByTxId(client, txId) {
-  return getTransaction(client, { txid: txId });
+async function transactionByTxId(resolve, txId) {
+  const receipt = await getTransaction(resolve(), { txid: txId });
+  if (!receipt)
+    return null;
+  const { result, ...rest } = receipt;
+  return result === undefined ? rest : { ...rest, result: cvToJSON(result) };
 }
-async function accountHistory(client, principal, limit) {
-  return getAccountHistory(client, { address: principal, limit });
+async function accountHistory(resolve, principal, limit) {
+  return getAccountHistory(resolve(), { address: principal, limit });
 }
-async function mempoolStats(client) {
-  return getMempoolStats(client);
+async function mempoolStats(resolve) {
+  return getMempoolStats(resolve());
 }
-async function nftHoldings(client, principal, limit) {
-  return getNftHoldings(client, { address: principal, limit });
+async function nftHoldings(resolve, principal, limit) {
+  return getNftHoldings(resolve(), { address: principal, limit });
 }
-function createStacksTools(client) {
+var EXTENDED = "Needs a host that serves the extended API.";
+function buildTools(resolve) {
   return {
     getStxBalance: import_ai.tool({
       description: "Get the STX balance (in micro-STX) for a Stacks principal.",
       inputSchema: import_zod.z.object({ principal: PRINCIPAL }),
-      execute: ({ principal }) => stxBalance(client, principal)
+      execute: ({ principal }) => stxBalance(resolve, principal)
     }),
     getAccountInfo: import_ai.tool({
-      description: "Get account info (balance, locked, nonce) for a Stacks principal.",
+      description: "Get the STX balance (micro-STX) and next nonce for a Stacks principal.",
       inputSchema: import_zod.z.object({ principal: PRINCIPAL }),
-      execute: ({ principal }) => accountInfo(client, principal)
+      execute: ({ principal }) => accountInfo(resolve, principal)
     }),
     getBlock: import_ai.tool({
-      description: "Fetch a Stacks block by height or hash. Omit both for the latest block.",
+      description: "Fetch one Stacks block by height or hash. Omit both for the latest block. Always returns a single block object.",
       inputSchema: import_zod.z.object({
         height: import_zod.z.number().int().nonnegative().optional(),
-        hash: import_zod.z.string().optional()
+        hash: BLOCK_HASH.optional()
       }),
-      execute: (args) => block(client, args)
+      execute: (args) => block(resolve, args)
     }),
     getBlockHeight: import_ai.tool({
       description: "Get the current Stacks chain tip height.",
       inputSchema: import_zod.z.object({}),
-      execute: () => blockHeight(client)
+      execute: () => blockHeight(resolve)
     }),
     readContract: import_ai.tool({
-      description: "Call a read-only Clarity function. Returns the decoded value as JSON.",
+      description: "Call a read-only Clarity function that takes no arguments. Returns the decoded value as JSON; uint and int arrive as decimal strings.",
       inputSchema: import_zod.z.object({
-        contract: import_zod.z.string().describe("Fully-qualified contract id: '{address}.{name}'"),
-        functionName: import_zod.z.string(),
+        contract: CONTRACT_ID,
+        functionName: FUNCTION_NAME,
         sender: PRINCIPAL.optional()
       }),
-      execute: (args) => contractRead(client, args)
+      execute: (args) => contractRead(resolve, args)
     }),
     estimateFee: import_ai.tool({
-      description: "Estimate fee range (low / medium / high) for a serialized Stacks transaction.",
+      description: "Estimate fee tiers (low / medium / high, in micro-STX) for a serialized Stacks transaction. `source` is 'node' for a live estimate or 'min' when the node had none and the relay minimum was used. `tiers` is how many estimates the node returned; when it is below 3 the missing tiers repeat the nearest lower one.",
       inputSchema: import_zod.z.object({
         serializedTxHex: import_zod.z.string().describe("Hex-encoded serialized transaction")
       }),
-      execute: ({ serializedTxHex }) => fee(client, serializedTxHex)
+      execute: ({ serializedTxHex }) => fee(resolve, serializedTxHex)
     }),
     bnsResolve: import_ai.tool({
       description: "Resolve a BNS name (e.g. 'satoshi.btc') to its owning Stacks principal.",
       inputSchema: import_zod.z.object({
         name: import_zod.z.string().describe("BNS name in 'name.namespace' form")
       }),
-      execute: ({ name }) => bnsResolveImpl(client, name)
+      execute: ({ name }) => bnsResolveImpl(resolve, name)
     }),
     bnsReverse: import_ai.tool({
       description: "Reverse-lookup the primary BNS name for a Stacks principal, if set.",
       inputSchema: import_zod.z.object({ principal: PRINCIPAL }),
-      execute: ({ principal }) => bnsReverseImpl(client, principal)
+      execute: ({ principal }) => bnsReverseImpl(resolve, principal)
     }),
     getTransaction: import_ai.tool({
-      description: "Fetch a confirmed Stacks transaction by txId (Hiro extended API).",
-      inputSchema: import_zod.z.object({
-        txId: import_zod.z.string().describe("Transaction id, with or without 0x prefix")
-      }),
-      execute: ({ txId }) => transactionByTxId(client, txId)
+      description: `Fetch a confirmed Stacks transaction by txId, with its decoded result as JSON. ${EXTENDED}`,
+      inputSchema: import_zod.z.object({ txId: TX_ID }),
+      execute: ({ txId }) => transactionByTxId(resolve, txId)
     }),
     getAccountHistory: import_ai.tool({
-      description: "Paginated transaction history for a Stacks principal (Hiro extended API).",
+      description: `List the most recent transactions for a Stacks principal (first page only, up to 50). ${EXTENDED}`,
       inputSchema: import_zod.z.object({
         principal: PRINCIPAL,
         limit: import_zod.z.number().int().min(1).max(50).default(20)
       }),
-      execute: ({ principal, limit }) => accountHistory(client, principal, limit)
+      execute: ({ principal, limit }) => accountHistory(resolve, principal, limit)
     }),
     getMempoolStats: import_ai.tool({
-      description: "Current mempool statistics: pending count, fee distribution, age buckets (Hiro extended API).",
+      description: `Current mempool statistics: pending count, fee distribution, age buckets. ${EXTENDED}`,
       inputSchema: import_zod.z.object({}),
-      execute: () => mempoolStats(client)
+      execute: () => mempoolStats(resolve)
     }),
     getNftHoldings: import_ai.tool({
-      description: "NFT holdings for a Stacks principal across all collections (Hiro extended API).",
+      description: `List NFTs held by a Stacks principal across all collections (first page only, up to 50). ${EXTENDED}`,
       inputSchema: import_zod.z.object({
         principal: PRINCIPAL,
         limit: import_zod.z.number().int().min(1).max(50).default(20)
       }),
-      execute: ({ principal, limit }) => nftHoldings(client, principal, limit)
+      execute: ({ principal, limit }) => nftHoldings(resolve, principal, limit)
     })
   };
 }
-var getStxBalance = import_ai.tool({
-  description: "Get the STX balance (in micro-STX) for a Stacks principal. Uses default client.",
-  inputSchema: import_zod.z.object({ principal: PRINCIPAL }),
-  execute: ({ principal }) => stxBalance(getDefaultPublicClient(), principal)
-});
-var getAccountInfo2 = import_ai.tool({
-  description: "Get account info (balance, locked, nonce) for a Stacks principal.",
-  inputSchema: import_zod.z.object({ principal: PRINCIPAL }),
-  execute: ({ principal }) => accountInfo(getDefaultPublicClient(), principal)
-});
-var getBlock2 = import_ai.tool({
-  description: "Fetch a Stacks block by height or hash. Omit both for the latest block.",
-  inputSchema: import_zod.z.object({
-    height: import_zod.z.number().int().nonnegative().optional(),
-    hash: import_zod.z.string().optional()
-  }),
-  execute: (args) => block(getDefaultPublicClient(), args)
-});
-var getBlockHeight2 = import_ai.tool({
-  description: "Get the current Stacks chain tip height.",
-  inputSchema: import_zod.z.object({}),
-  execute: () => blockHeight(getDefaultPublicClient())
-});
-var readContract2 = import_ai.tool({
-  description: "Call a read-only Clarity function. Returns the decoded value as JSON.",
-  inputSchema: import_zod.z.object({
-    contract: import_zod.z.string(),
-    functionName: import_zod.z.string(),
-    sender: PRINCIPAL.optional()
-  }),
-  execute: (args) => contractRead(getDefaultPublicClient(), args)
-});
-var estimateFee2 = import_ai.tool({
-  description: "Estimate fee range (low / medium / high) for a serialized Stacks transaction.",
-  inputSchema: import_zod.z.object({ serializedTxHex: import_zod.z.string() }),
-  execute: ({ serializedTxHex }) => fee(getDefaultPublicClient(), serializedTxHex)
-});
-var bnsResolve = import_ai.tool({
-  description: "Resolve a BNS name (e.g. 'satoshi.btc') to its owning Stacks principal.",
-  inputSchema: import_zod.z.object({ name: import_zod.z.string() }),
-  execute: ({ name }) => bnsResolveImpl(getDefaultPublicClient(), name)
-});
-var bnsReverse = import_ai.tool({
-  description: "Reverse-lookup the primary BNS name for a Stacks principal, if set.",
-  inputSchema: import_zod.z.object({ principal: PRINCIPAL }),
-  execute: ({ principal }) => bnsReverseImpl(getDefaultPublicClient(), principal)
-});
-var getTransaction2 = import_ai.tool({
-  description: "Fetch a confirmed Stacks transaction by txId (Hiro extended API).",
-  inputSchema: import_zod.z.object({ txId: import_zod.z.string() }),
-  execute: ({ txId }) => transactionByTxId(getDefaultPublicClient(), txId)
-});
-var getAccountHistory2 = import_ai.tool({
-  description: "Paginated transaction history for a Stacks principal (Hiro extended API).",
-  inputSchema: import_zod.z.object({
-    principal: PRINCIPAL,
-    limit: import_zod.z.number().int().min(1).max(50).default(20)
-  }),
-  execute: ({ principal, limit }) => accountHistory(getDefaultPublicClient(), principal, limit)
-});
-var getMempoolStats2 = import_ai.tool({
-  description: "Current mempool statistics: pending count, fee distribution, age buckets (Hiro extended API).",
-  inputSchema: import_zod.z.object({}),
-  execute: () => mempoolStats(getDefaultPublicClient())
-});
-var getNftHoldings2 = import_ai.tool({
-  description: "NFT holdings for a Stacks principal across all collections (Hiro extended API).",
-  inputSchema: import_zod.z.object({
-    principal: PRINCIPAL,
-    limit: import_zod.z.number().int().min(1).max(50).default(20)
-  }),
-  execute: ({ principal, limit }) => nftHoldings(getDefaultPublicClient(), principal, limit)
-});
-
-//# debugId=A0859ACF613066D264756E2164756E21
+function createStacksTools(client) {
+  return buildTools(() => client);
+}
+var defaultTools = buildTools(getDefaultPublicClient);
+var getStxBalance = defaultTools.getStxBalance;
+var getAccountInfo2 = defaultTools.getAccountInfo;
+var getBlock2 = defaultTools.getBlock;
+var getBlockHeight2 = defaultTools.getBlockHeight;
+var readContract2 = defaultTools.readContract;
+var estimateFee2 = defaultTools.estimateFee;
+var bnsResolve = defaultTools.bnsResolve;
+var bnsReverse = defaultTools.bnsReverse;
+var getTransaction2 = defaultTools.getTransaction;
+var getAccountHistory2 = defaultTools.getAccountHistory;
+var getMempoolStats2 = defaultTools.getMempoolStats;
+var getNftHoldings2 = defaultTools.getNftHoldings;
+
+//# debugId=BA352497F272866664756E2164756E21
 //# sourceMappingURL=index.cjs.map