@secondlayer/stacks 6.1.0 → 6.1.2

package/dist/shared/{stacks-esm-qk0p9fr6.js → stacks-esm-ea4m4bk7.js}

@@ -1,43 +1,43 @@
 import {
-  MalformedResponseError
-} from "./stacks-esm-743jfh10.js";
+  bytesToHex2,
+  with0x2,
+  intToBigInt2
+} from "./stacks-esm-7a0ehykf.js";
 import {
-  buildContractCall,
-  getTransactionId,
-  signTransactionWithAccount
-} from "./stacks-esm-r9q4wnyw.js";
+  serializeCVBytes2,
+  BroadcastError2,
+  TransactionAbortedError2,
+  TransactionDroppedError2,
+  WaitForTransactionTimeoutError2,
+  deserializeCVBytes2
+} from "./stacks-esm-hkw1kvd4.js";
 import {
-  clearTxCache,
   serializePayload,
-  serializeTransaction
-} from "./stacks-esm-skmcf5n2.js";
+  clearTxCache,
+  serializeTransaction2
+} from "./stacks-esm-phgy8yqf.js";
 import {
-  BroadcastError,
-  TransactionAbortedError,
-  TransactionDroppedError,
-  WaitForTransactionTimeoutError,
-  deserializeCVBytes,
-  serializeCVBytes
-} from "./stacks-esm-fcfdn2zx.js";
+  parseContractId2
+} from "./stacks-esm-kbz5s6v8.js";
 import {
-  BaseError
-} from "./stacks-esm-1jae0a3r.js";
+  buildContractCall2,
+  signTransactionWithAccount2,
+  getTransactionId2
+} from "./stacks-esm-cmtj5vky.js";
 import {
-  parseContractId
-} from "./stacks-esm-2mc7ebrm.js";
+  MalformedResponseError2
+} from "./stacks-esm-0pc6tmf0.js";
 import {
-  bytesToHex,
-  intToBigInt,
-  with0x
-} from "./stacks-esm-cvhazvhd.js";
+  BaseError2
+} from "./stacks-esm-7v18h5dk.js";
 
 // src/actions/public/estimateFee.ts
 function isValidEstimation(e) {
   return typeof e === "object" && e !== null && "fee_rate" in e && "fee" in e && (typeof e.fee_rate === "number" || typeof e.fee_rate === "string") && (typeof e.fee === "number" || typeof e.fee === "string");
 }
-async function estimateFee(client, params) {
-  const payloadHex = bytesToHex(serializePayload(params.transaction.payload));
-  const txHex = bytesToHex(serializeTransaction(params.transaction));
+async function estimateFee2(client, params) {
+  const payloadHex = bytesToHex2(serializePayload(params.transaction.payload));
+  const txHex = bytesToHex2(serializeTransaction2(params.transaction));
   const data = await client.request("/v2/fees/transaction", {
     method: "POST",
     body: {
@@ -48,7 +48,7 @@ async function estimateFee(client, params) {
   const raw = data?.estimations ?? [];
   return raw.map((e) => {
     if (!isValidEstimation(e)) {
-      throw new MalformedResponseError("estimateFee: node response contains invalid fee estimation entry");
+      throw new MalformedResponseError2("estimateFee: node response contains invalid fee estimation entry");
     }
     return {
       feeRate: Number(e.fee_rate),
@@ -58,16 +58,16 @@ async function estimateFee(client, params) {
 }
 
 // src/actions/public/getBlockHeight.ts
-async function getBlockHeight(client) {
+async function getBlockHeight2(client) {
   const data = await client.request("/v2/info", { method: "GET" });
   if (typeof data?.stacks_tip_height !== "number") {
-    throw new MalformedResponseError('getBlockHeight: /v2/info response is missing "stacks_tip_height"');
+    throw new MalformedResponseError2('getBlockHeight: /v2/info response is missing "stacks_tip_height"');
   }
   return data.stacks_tip_height;
 }
 
 // src/errors/http.ts
-class HttpRequestError extends BaseError {
+class HttpRequestError2 extends BaseError2 {
   name = "HttpRequestError";
   status;
   url;
@@ -82,31 +82,31 @@ class HttpRequestError extends BaseError {
 }
 
 // src/actions/public/getMapEntry.ts
-async function getMapEntry(client, params) {
-  const [address, name] = parseContractId(params.contract);
-  const serializedKey = with0x(bytesToHex(serializeCVBytes(params.key)));
+async function getMapEntry2(client, params) {
+  const [address, name] = parseContractId2(params.contract);
+  const serializedKey = with0x2(bytesToHex2(serializeCVBytes2(params.key)));
   const data = await client.request(`/v2/map_entry/${address}/${name}/${params.mapName}`, {
     method: "POST",
     body: serializedKey
   });
   if (typeof data?.data !== "string") {
-    throw new MalformedResponseError(`getMapEntry: /v2/map_entry/${address}/${name}/${params.mapName} response is missing "data"`);
+    throw new MalformedResponseError2(`getMapEntry: /v2/map_entry/${address}/${name}/${params.mapName} response is missing "data"`);
   }
-  return deserializeCVBytes(data.data);
+  return deserializeCVBytes2(data.data);
 }
 
 // src/actions/public/getNonce.ts
-async function getNonce(client, params) {
+async function getNonce2(client, params) {
   const data = await client.request(`/v2/accounts/${encodeURIComponent(params.address)}`, { method: "GET" });
   const nonce = data?.nonce;
   if (typeof nonce !== "number" && typeof nonce !== "string") {
-    throw new MalformedResponseError(`getNonce: /v2/accounts/${params.address} response is missing "nonce"`);
+    throw new MalformedResponseError2(`getNonce: /v2/accounts/${params.address} response is missing "nonce"`);
   }
   return BigInt(nonce);
 }
 
 // src/errors/transport.ts
-class TimeoutError extends BaseError {
+class TimeoutError2 extends BaseError2 {
   name = "TimeoutError";
   method;
   url;
@@ -187,7 +187,7 @@ async function fetchWithRetry(url, options, retryCount, retryDelay, timeout, ext
     let timedOut = false;
     const timeoutId = setTimeout(() => {
       timedOut = true;
-      controller.abort(new TimeoutError({ method, url, timeout, attempt }));
+      controller.abort(new TimeoutError2({ method, url, timeout, attempt }));
     }, timeout);
     const onCallerAbort = () => controller.abort(abortReason(signal));
     signal?.addEventListener("abort", onCallerAbort, { once: true });
@@ -206,7 +206,7 @@ async function fetchWithRetry(url, options, retryCount, retryDelay, timeout, ext
       } catch (error) {
         if (signal?.aborted)
           throw abortReason(signal);
-        lastError = timedOut ? new TimeoutError({ method, url, timeout, attempt }) : error instanceof Error ? error : new Error(String(error));
+        lastError = timedOut ? new TimeoutError2({ method, url, timeout, attempt }) : error instanceof Error ? error : new Error(String(error));
         if (attempt < retryCount) {
           clearTimeout(timeoutId);
           await sleep(retryDelay * (attempt + 1), signal);
@@ -223,7 +223,7 @@ async function fetchWithRetry(url, options, retryCount, retryDelay, timeout, ext
             throw abortReason(signal);
           if (!timedOut)
             throw error;
-          lastError = new TimeoutError({ method, url, timeout, attempt });
+          lastError = new TimeoutError2({ method, url, timeout, attempt });
           if (attempt < retryCount) {
             clearTimeout(timeoutId);
             await sleep(retryDelay * (attempt + 1), signal);
@@ -242,13 +242,13 @@ async function fetchWithRetry(url, options, retryCount, retryDelay, timeout, ext
             return;
           })
         ]);
-        throw new HttpRequestError(response.status, {
+        throw new HttpRequestError2(response.status, {
           details: capDetails(body),
           url,
           method
         });
       }
-      lastError = new HttpRequestError(response.status, { url, method });
+      lastError = new HttpRequestError2(response.status, { url, method });
       const delay = retryAfterMs(response) ?? retryDelay * (attempt + 1);
       response.body?.cancel().catch(() => {});
       clearTimeout(timeoutId);
@@ -298,7 +298,7 @@ function buildRequestFn(baseUrl, config) {
 }
 
 // src/actions/public/txSources.ts
-class IndexSourceConfigError extends Error {
+class IndexSourceConfigError2 extends Error {
   name = "IndexSourceConfigError";
 }
 function isHiroHost(url, client) {
@@ -323,10 +323,10 @@ function indexRequestFn(client, baseUrl, sourceName) {
   const transportUrl = client.transport.config.url?.replace(/\/$/, "");
   if (baseUrl === undefined) {
     if (!transportUrl) {
-      throw new IndexSourceConfigError(`${sourceName} needs the URL of your Secondlayer instance: pass baseUrl, or use an http() transport pointed at the instance`);
+      throw new IndexSourceConfigError2(`${sourceName} needs the URL of your Secondlayer instance: pass baseUrl, or use an http() transport pointed at the instance`);
     }
     if (isHiroHost(transportUrl, client)) {
-      throw new IndexSourceConfigError(`${sourceName} reads /v1/index on a Secondlayer instance, and ${transportUrl} is a Hiro host: pass baseUrl with the URL of your instance`);
+      throw new IndexSourceConfigError2(`${sourceName} reads /v1/index on a Secondlayer instance, and ${transportUrl} is a Hiro host: pass baseUrl with the URL of your instance`);
     }
     return client.request;
   }
@@ -337,7 +337,7 @@ function indexRequestFn(client, baseUrl, sourceName) {
   return buildRequestFn(target, { timeout, retryCount, retryDelay });
 }
 function indexNotFound(error, sourceName) {
-  if (!(error instanceof HttpRequestError) || error.status !== 404) {
+  if (!(error instanceof HttpRequestError2) || error.status !== 404) {
     return false;
   }
   const body = error.details;
@@ -345,7 +345,7 @@ function indexNotFound(error, sourceName) {
     try {
       JSON.parse(body);
     } catch {
-      throw new IndexSourceConfigError(`${sourceName} got a non-JSON 404 from ${error.url ?? "the transport host"}: it does not serve /v1/index, pass baseUrl with the URL of your Secondlayer instance`, { cause: error });
+      throw new IndexSourceConfigError2(`${sourceName} got a non-JSON 404 from ${error.url ?? "the transport host"}: it does not serve /v1/index, pass baseUrl with the URL of your Secondlayer instance`, { cause: error });
     }
   }
   return true;
@@ -357,7 +357,7 @@ function decodeResultHex(hex) {
   if (!hex)
     return {};
   try {
-    return { result: deserializeCVBytes(hex), resultHex: hex };
+    return { result: deserializeCVBytes2(hex), resultHex: hex };
   } catch {
     return { resultHex: hex };
   }
@@ -373,14 +373,14 @@ function normalizeStatus(txStatus) {
       return txStatus.startsWith("dropped") ? "dropped" : undefined;
   }
 }
-function extendedApiSource() {
+function extendedApiSource2() {
   return {
     async get({ client, txid }) {
       let data;
       try {
         data = await client.request(`/extended/v1/tx/${encodeURIComponent(normalizeTxid(txid))}`, { method: "GET" });
       } catch (error) {
-        if (error instanceof HttpRequestError && error.status === 404) {
+        if (error instanceof HttpRequestError2 && error.status === 404) {
           return { receipt: null };
         }
         throw error;
@@ -405,7 +405,7 @@ function extendedApiSource() {
     }
   };
 }
-function indexTxSource(params = {}) {
+function indexTxSource2(params = {}) {
   const headers = params.apiKey ? { authorization: `Bearer ${params.apiKey}` } : undefined;
   return {
     canonicalOnly: true,
@@ -443,22 +443,22 @@ function indexTxSource(params = {}) {
 }
 
 // src/actions/public/getTransaction.ts
-async function getTransaction(client, params) {
-  const source = params.source ?? extendedApiSource();
+async function getTransaction2(client, params) {
+  const source = params.source ?? extendedApiSource2();
   const { receipt } = await source.get({ client, txid: params.txid });
   return receipt;
 }
 
 // src/actions/public/waitForTransactionReceipt.ts
 var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
-async function waitForTransactionReceipt(client, params) {
+async function waitForTransactionReceipt2(client, params) {
   const {
     txid,
     confirmations = 1,
     timeout = 180000,
     pollingInterval = 3000
   } = params;
-  const source = params.source ?? extendedApiSource();
+  const source = params.source ?? extendedApiSource2();
   const droppedGracePeriod = params.droppedGracePeriod ?? (source.canonicalOnly ? timeout : 30000);
   const startedAt = Date.now();
   let unknownSince = null;
@@ -469,16 +469,16 @@ async function waitForTransactionReceipt(client, params) {
     if (receipt === null) {
       unknownSince ??= Date.now();
       if (Date.now() - unknownSince >= droppedGracePeriod) {
-        throw new TransactionDroppedError(everPending ? `Transaction ${txid} left the mempool without being mined` : `Transaction ${txid} was never observed by the status source`, { txid });
+        throw new TransactionDroppedError2(everPending ? `Transaction ${txid} left the mempool without being mined` : `Transaction ${txid} was never observed by the status source`, { txid });
       }
     } else {
       unknownSince = null;
       switch (receipt.status) {
         case "dropped":
-          throw new TransactionDroppedError(`Transaction ${txid} was dropped from the mempool`, { txid });
+          throw new TransactionDroppedError2(`Transaction ${txid} was dropped from the mempool`, { txid });
         case "abort_by_response":
         case "abort_by_post_condition":
-          throw new TransactionAbortedError(`Transaction ${txid} aborted (${receipt.status})`, { receipt });
+          throw new TransactionAbortedError2(`Transaction ${txid} aborted (${receipt.status})`, { receipt });
         case "pending":
           everPending = true;
           break;
@@ -486,7 +486,7 @@ async function waitForTransactionReceipt(client, params) {
           if (confirmations <= 1)
             return receipt;
           if (receipt.blockHeight !== undefined) {
-            const tip = snapshot.tip ?? await getBlockHeight(client);
+            const tip = snapshot.tip ?? await getBlockHeight2(client);
             if (tip - receipt.blockHeight + 1 >= confirmations)
               return receipt;
           }
@@ -495,18 +495,18 @@ async function waitForTransactionReceipt(client, params) {
       }
     }
     if (Date.now() - startedAt >= timeout) {
-      throw new WaitForTransactionTimeoutError(`Timed out after ${timeout}ms waiting for transaction ${txid}`, { txid });
+      throw new WaitForTransactionTimeoutError2(`Timed out after ${timeout}ms waiting for transaction ${txid}`, { txid });
     }
     await sleep2(pollingInterval);
   }
 }
 
 // src/actions/wallet/sendTransaction.ts
-async function sendTransaction(client, params) {
-  const hex = bytesToHex(serializeTransaction(params.transaction));
+async function sendTransaction2(client, params) {
+  const hex = bytesToHex2(serializeTransaction2(params.transaction));
   const body = { tx: hex };
   if (params.attachment) {
-    body.attachment = typeof params.attachment === "string" ? params.attachment : bytesToHex(params.attachment);
+    body.attachment = typeof params.attachment === "string" ? params.attachment : bytesToHex2(params.attachment);
   }
   let data;
   try {
@@ -516,33 +516,33 @@ async function sendTransaction(client, params) {
       retryCount: 0
     });
   } catch (error) {
-    if (error instanceof HttpRequestError && error.details) {
+    if (error instanceof HttpRequestError2 && error.details) {
       try {
         data = JSON.parse(error.details);
       } catch {
         throw error;
       }
-    } else if (error instanceof TimeoutError) {
-      const txid2 = getTransactionId(params.transaction);
-      const receipt = await getTransaction(client, { txid: txid2 }).catch(() => null);
+    } else if (error instanceof TimeoutError2) {
+      const txid = getTransactionId2(params.transaction);
+      const receipt = await getTransaction2(client, { txid }).catch(() => null);
       if (receipt === null)
         throw error;
-      data = { txid: txid2 };
+      data = { txid };
     } else {
       throw error;
     }
   }
   if (data.error) {
-    throw new BroadcastError(data.reason ?? data.error, {
+    throw new BroadcastError2(data.reason ?? data.error, {
       reason: data.reason,
       reasonData: data.reason_data,
-      txid: data.txid ?? getTransactionId(params.transaction)
+      txid: data.txid ?? getTransactionId2(params.transaction)
     });
   }
-  const txid = typeof data === "string" ? data.replace(/"/g, "") : data.txid ?? getTransactionId(params.transaction);
+  const txid = typeof data === "string" ? data.replace(/"/g, "") : data.txid ?? getTransactionId2(params.transaction);
   if (params.wait) {
     const confirmations = params.wait === true ? 1 : params.wait;
-    const receipt = await waitForTransactionReceipt(client, {
+    const receipt = await waitForTransactionReceipt2(client, {
       txid,
       confirmations
     });
@@ -552,12 +552,12 @@ async function sendTransaction(client, params) {
 }
 
 // src/actions/wallet/nonceManager.ts
-function jsonRpcSource() {
+function jsonRpcSource2() {
   return {
-    get: ({ client, address }) => getNonce(client, { address })
+    get: ({ client, address }) => getNonce2(client, { address })
   };
 }
-function memoryStore() {
+function memoryStore2() {
   const next = new Map;
   const locks = new Map;
   function withLock(key, fn) {
@@ -593,9 +593,9 @@ function memoryStore() {
 function nonceKey(client, address) {
   return `${client.chain?.id ?? "stacks"}:${address}`;
 }
-function createNonceManager(params = {}) {
-  const source = params.source ?? jsonRpcSource();
-  const store = params.store ?? memoryStore();
+function createNonceManager2(params = {}) {
+  const source = params.source ?? jsonRpcSource2();
+  const store = params.store ?? memoryStore2();
   return {
     consume({ client, address }) {
       return store.reserve(nonceKey(client, address), () => source.get({ client, address }));
@@ -611,10 +611,10 @@ function createNonceManager(params = {}) {
     }
   };
 }
-async function resolveNonce(client, address) {
+async function resolveNonce2(client, address) {
   if (client.nonceManager)
     return client.nonceManager.consume({ client, address });
-  return getNonce(client, { address });
+  return getNonce2(client, { address });
 }
 async function releaseNonce(client, address, nonce) {
   if (!client.nonceManager)
@@ -623,7 +623,7 @@ async function releaseNonce(client, address, nonce) {
     await client.nonceManager.release({ client, address, nonce });
   } catch {}
 }
-async function reconcileNonce(manager, params) {
+async function reconcileNonce2(manager, params) {
   const { client, address, source } = params;
   const downward = params.downward ?? true;
   const authoritative = await source.get({ client, address });
@@ -637,7 +637,7 @@ async function reconcileNonce(manager, params) {
   await manager.reset({ client, address });
   return { reset: true, authoritative, tracked };
 }
-function startNonceReconciler(manager, params) {
+function startNonceReconciler2(manager, params) {
   const { client, addresses, source, clock } = params;
   const intervalMs = params.intervalMs ?? 60000;
   let running = true;
@@ -646,7 +646,7 @@ function startNonceReconciler(manager, params) {
       return;
     for (const address of addresses) {
       try {
-        const result = await reconcileNonce(manager, {
+        const result = await reconcileNonce2(manager, {
           client,
           address,
           source,
@@ -678,8 +678,8 @@ function startNonceReconciler(manager, params) {
     stop: () => clearInterval(timer)
   };
 }
-function isNonceConflictError(error) {
-  if (!(error instanceof BroadcastError))
+function isNonceConflictError2(error) {
+  if (!(error instanceof BroadcastError2))
     return false;
   if (error.reason === "ConflictingNonceInMempool" || error.reason === "BadNonce") {
     return true;
@@ -688,14 +688,14 @@ function isNonceConflictError(error) {
     return false;
   return error.message.toLowerCase().includes("nonce");
 }
-async function broadcastWithNonceReset(client, params) {
+async function broadcastWithNonceReset2(client, params) {
   try {
-    const result = await sendTransaction(client, {
+    const result = await sendTransaction2(client, {
       transaction: params.transaction
     });
     return result.txid;
   } catch (error) {
-    if (client.nonceManager && isNonceConflictError(error)) {
+    if (client.nonceManager && isNonceConflictError2(error)) {
       await client.nonceManager.reset({ client, address: params.address });
     }
     throw error;
@@ -703,56 +703,56 @@ async function broadcastWithNonceReset(client, params) {
 }
 
 // src/actions/wallet/utils.ts
-function isProviderAccount(account) {
+function isProviderAccount2(account) {
   return account.type === "provider";
 }
 var FEE_TIERS = ["min", "low", "mid", "high"];
 var TIER_INDEX = { low: 0, mid: 1, high: 2 };
-function isFeeTier(fee) {
+function isFeeTier2(fee) {
   return typeof fee === "string" && FEE_TIERS.includes(fee);
 }
-function minimumFee(transaction) {
-  return BigInt(serializeTransaction(transaction).length);
+function minimumFee2(transaction) {
+  return BigInt(serializeTransaction2(transaction).length);
 }
-function isNoEstimateAvailable(error) {
-  return error instanceof HttpRequestError && error.status === 400 && (error.details?.includes("NoEstimateAvailable") ?? false);
+function isNoEstimateAvailable2(error) {
+  return error instanceof HttpRequestError2 && error.status === 400 && (error.details?.includes("NoEstimateAvailable") ?? false);
 }
-async function resolveFee(client, transaction, fee) {
-  if (fee !== undefined && !isFeeTier(fee))
-    return { fee: intToBigInt(fee) };
+async function resolveFee2(client, transaction, fee) {
+  if (fee !== undefined && !isFeeTier2(fee))
+    return { fee: intToBigInt2(fee) };
   const tier = fee ?? "mid";
   if (tier === "min")
-    return { fee: minimumFee(transaction), tier };
+    return { fee: minimumFee2(transaction), tier };
   let estimates;
   try {
-    estimates = await estimateFee(client, { transaction });
+    estimates = await estimateFee2(client, { transaction });
   } catch (error) {
-    if (!isNoEstimateAvailable(error))
+    if (!isNoEstimateAvailable2(error))
       throw error;
-    return { fee: minimumFee(transaction), tier: "min" };
+    return { fee: minimumFee2(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" };
+  return { fee: minimumFee2(transaction), tier: "min" };
 }
 function setUnsignedFee(transaction, fee) {
   transaction.auth.spendingCondition.fee = fee;
   clearTxCache(transaction);
 }
 function assertNoFeeTierForProvider(fee) {
-  if (isFeeTier(fee)) {
+  if (isFeeTier2(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) {
+async function callContract2(client, params) {
   const account = client.account;
   if (!account)
     throw new Error("Account required");
-  const [contractAddress, contractName] = parseContractId(params.contract);
-  if (isProviderAccount(account)) {
+  const [contractAddress, contractName] = parseContractId2(params.contract);
+  if (isProviderAccount2(account)) {
     assertNoFeeTierForProvider(params.fee);
     const result = await account.provider.request("stx_callContract", {
       contract: params.contract,
@@ -762,10 +762,10 @@ 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 nonce = params.nonce ?? await resolveNonce2(client, account.address);
   try {
-    const needsFeeResolution = params.fee === undefined || isFeeTier(params.fee);
-    const unsigned = buildContractCall({
+    const needsFeeResolution = params.fee === undefined || isFeeTier2(params.fee);
+    const unsigned = buildContractCall2({
       contractAddress,
       contractName,
       functionName: params.functionName,
@@ -778,11 +778,11 @@ async function callContract(client, params) {
       postConditions: params.postConditions
     });
     if (needsFeeResolution) {
-      const { fee } = await resolveFee(client, unsigned, params.fee);
+      const { fee } = await resolveFee2(client, unsigned, params.fee);
       setUnsignedFee(unsigned, fee);
     }
-    const signed = await signTransactionWithAccount(unsigned, account);
-    return await broadcastWithNonceReset(client, {
+    const signed = await signTransactionWithAccount2(unsigned, account);
+    return await broadcastWithNonceReset2(client, {
       transaction: signed,
       address: account.address
     });
@@ -793,7 +793,7 @@ async function callContract(client, params) {
   }
 }
 
-export { estimateFee, getBlockHeight, HttpRequestError, getMapEntry, getNonce, TimeoutError, createTransport, buildRequestFn, IndexSourceConfigError, indexRequestFn, indexNotFound, extendedApiSource, indexTxSource, getTransaction, waitForTransactionReceipt, sendTransaction, jsonRpcSource, memoryStore, createNonceManager, resolveNonce, releaseNonce, reconcileNonce, startNonceReconciler, isNonceConflictError, broadcastWithNonceReset, isProviderAccount, isFeeTier, minimumFee, isNoEstimateAvailable, resolveFee, setUnsignedFee, assertNoFeeTierForProvider, callContract };
+export { estimateFee2, getBlockHeight2, HttpRequestError2, getMapEntry2, getNonce2, TimeoutError2, createTransport, buildRequestFn, IndexSourceConfigError2, indexRequestFn, indexNotFound, extendedApiSource2, indexTxSource2, getTransaction2, waitForTransactionReceipt2, sendTransaction2, jsonRpcSource2, memoryStore2, createNonceManager2, resolveNonce2, releaseNonce, reconcileNonce2, startNonceReconciler2, isNonceConflictError2, broadcastWithNonceReset2, isProviderAccount2, isFeeTier2, minimumFee2, isNoEstimateAvailable2, resolveFee2, setUnsignedFee, assertNoFeeTierForProvider, callContract2 };
 
-//# debugId=D0127FA0D8988A0264756E2164756E21
-//# sourceMappingURL=stacks-esm-qk0p9fr6.js.map
+//# debugId=863F4AC28F71513464756E2164756E21
+//# sourceMappingURL=stacks-esm-ea4m4bk7.js.map