@secondlayer/stacks 4.3.1 → 5.0.0

package/dist/shared/{stacks-fb75yew8.js → stacks-db3kwavg.cjs}

@@ -1,32 +1,3 @@
-import {
-  MalformedResponseError
-} from "./stacks-27fmgajb.js";
-import {
-  BaseError
-} from "./stacks-709tra19.js";
-import {
-  buildContractCall,
-  getTransactionId,
-  signTransactionWithAccount
-} from "./stacks-hnqt5rz4.js";
-import {
-  clearTxCache,
-  serializePayload,
-  serializeTransaction
-} from "./stacks-w23294am.js";
-import {
-  deserializeCVBytes,
-  serializeCVBytes
-} from "./stacks-ttdk2g2f.js";
-import {
-  parseContractId
-} from "./stacks-bfan7ex7.js";
-import {
-  bytesToHex,
-  intToBigInt,
-  with0x
-} from "./stacks-qs5fzts5.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");
@@ -66,9 +37,14 @@ async function getBlockHeight(client) {
 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;
   }
 }
 
@@ -98,12 +74,250 @@ async function getNonce(client, params) {
   return BigInt(nonce);
 }
 
+// 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 resolveFetch(fetchImpl) {
-  const f = fetchImpl ?? globalThis.fetch;
-  if (!f)
-    throw new Error("No fetch implementation available; pass `fetchImpl`");
-  return f;
+class IndexSourceConfigError extends Error {
+  name = "IndexSourceConfigError";
+}
+function isHiroHost(url, client) {
+  let hostname;
+  try {
+    hostname = new URL(url).hostname;
+  } catch {
+    return false;
+  }
+  if (hostname === "hiro.so" || hostname.endsWith(".hiro.so"))
+    return true;
+  const defaults = client.chain?.rpcUrls?.default?.http ?? [];
+  return defaults.some((d) => {
+    try {
+      return new URL(d).hostname === hostname && hostname !== "localhost";
+    } catch {
+      return false;
+    }
+  });
+}
+function indexRequestFn(client, baseUrl, sourceName) {
+  const transportUrl = client.transport.config.url?.replace(/\/$/, "");
+  if (baseUrl === undefined) {
+    if (!transportUrl) {
+      throw new IndexSourceConfigError(`${sourceName} needs the URL of your Secondlayer instance: pass baseUrl, or use an http() transport pointed at the instance`);
+    }
+    if (isHiroHost(transportUrl, client)) {
+      throw new IndexSourceConfigError(`${sourceName} reads /v1/index on a Secondlayer instance, and ${transportUrl} is a Hiro host: pass baseUrl with the URL of your instance`);
+    }
+    return client.request;
+  }
+  const target = baseUrl.replace(/\/$/, "");
+  if (target === transportUrl)
+    return client.request;
+  const { timeout, retryCount, retryDelay } = client.transport.config;
+  return buildRequestFn(target, { timeout, retryCount, retryDelay });
+}
+function indexNotFound(error, sourceName) {
+  if (!(error instanceof HttpRequestError) || error.status !== 404) {
+    return false;
+  }
+  const body = error.details;
+  if (body !== undefined) {
+    try {
+      JSON.parse(body);
+    } catch {
+      throw new IndexSourceConfigError(`${sourceName} got a non-JSON 404 from ${error.url ?? "the transport host"}: it does not serve /v1/index, pass baseUrl with the URL of your Secondlayer instance`, { cause: error });
+    }
+  }
+  return true;
 }
 function normalizeTxid(txid) {
   return txid.startsWith("0x") ? txid : `0x${txid}`;
@@ -133,9 +347,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 };
@@ -163,20 +375,22 @@ function extendedApiSource() {
   };
 }
 function indexTxSource(params = {}) {
-  const baseUrl = (params.baseUrl ?? "https://api.secondlayer.tools").replace(/\/$/, "");
-  const fetchImpl = resolveFetch(params.fetchImpl);
+  const headers = params.apiKey ? { authorization: `Bearer ${params.apiKey}` } : undefined;
   return {
-    async get({ txid }) {
-      const res = await fetchImpl(`${baseUrl}/v1/index/transactions/${normalizeTxid(txid)}`, {
-        headers: params.apiKey ? { "x-api-key": params.apiKey } : undefined
-      });
-      if (res.status === 404) {
-        return { receipt: null };
-      }
-      if (!res.ok) {
-        throw new Error(`indexTxSource: /v1/index/transactions ${res.status}`);
+    canonicalOnly: true,
+    async get({ client, txid }) {
+      const request = indexRequestFn(client, params.baseUrl, "indexTxSource");
+      let data;
+      try {
+        data = await request(`/v1/index/transactions/${normalizeTxid(txid)}`, {
+          method: "GET",
+          headers
+        });
+      } catch (error) {
+        if (indexNotFound(error, "indexTxSource"))
+          return { receipt: null };
+        throw error;
       }
-      const data = await res.json();
       const tx = data.transaction;
       const tip = data.tip?.block_height;
       if (!tx)
@@ -197,70 +411,24 @@ function indexTxSource(params = {}) {
   };
 }
 
-// src/errors/transaction.ts
-class TransactionError extends BaseError {
-  name = "TransactionError";
-}
-
-class BroadcastError extends BaseError {
-  name = "BroadcastError";
-  txid;
-  reason;
-  reasonData;
-  constructor(message, options) {
-    super(message, options);
-    this.txid = options?.txid;
-    this.reason = options?.reason;
-    this.reasonData = options?.reasonData;
-  }
-}
-
-class TransactionAbortedError extends BaseError {
-  name = "TransactionAbortedError";
-  receipt;
-  constructor(message, options) {
-    super(message, options);
-    this.receipt = options.receipt;
-  }
-}
-
-class TransactionDroppedError extends BaseError {
-  name = "TransactionDroppedError";
-  txid;
-  constructor(message, options) {
-    super(message, options);
-    this.txid = options.txid;
-  }
-}
-
-class WaitForTransactionTimeoutError extends BaseError {
-  name = "WaitForTransactionTimeoutError";
-  txid;
-  constructor(message, options) {
-    super(message, options);
-    this.txid = options.txid;
-  }
-}
-
-class SerializationError extends BaseError {
-  name = "SerializationError";
-}
-
-class SigningError extends BaseError {
-  name = "SigningError";
+// src/actions/public/getTransaction.ts
+async function getTransaction(client, params) {
+  const source = params.source ?? extendedApiSource();
+  const { receipt } = await source.get({ client, txid: params.txid });
+  return receipt;
 }
 
 // src/actions/public/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,
     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;
@@ -298,7 +466,7 @@ async function waitForTransactionReceipt(client, params) {
     if (Date.now() - startedAt >= timeout) {
       throw new WaitForTransactionTimeoutError(`Timed out after ${timeout}ms waiting for transaction ${txid}`, { txid });
     }
-    await sleep(pollingInterval);
+    await sleep2(pollingInterval);
   }
 }
 
@@ -311,7 +479,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 {
@@ -319,6 +491,12 @@ async function sendTransaction(client, params) {
       } catch {
         throw error;
       }
+    } else if (error instanceof TimeoutError) {
+      const txid2 = getTransactionId(params.transaction);
+      const receipt = await getTransaction(client, { txid: txid2 }).catch(() => null);
+      if (receipt === null)
+        throw error;
+      data = { txid: txid2 };
     } else {
       throw error;
     }
@@ -370,6 +548,12 @@ function memoryStore() {
     reset(key) {
       next.delete(key);
     },
+    release(key, nonce) {
+      return withLock(key, async () => {
+        if (next.get(key) === nonce + 1n)
+          next.set(key, nonce);
+      });
+    },
     peek(key) {
       return next.get(key);
     }
@@ -388,6 +572,9 @@ function createNonceManager(params = {}) {
     reset({ client, address }) {
       return store.reset(nonceKey(client, address));
     },
+    release({ client, address, nonce }) {
+      return store.release?.(nonceKey(client, address), nonce);
+    },
     async peek({ client, address }) {
       return store.peek?.(nonceKey(client, address));
     }
@@ -398,6 +585,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 {}
+}
 async function reconcileNonce(manager, params) {
   const { client, address, source } = params;
   const downward = params.downward ?? true;
@@ -489,19 +683,27 @@ function isFeeTier(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 intToBigInt(fee);
+    return { fee: intToBigInt(fee) };
   const tier = fee ?? "mid";
   if (tier === "min")
-    return minimumFee(transaction);
+    return { fee: minimumFee(transaction), tier };
+  let estimates;
   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);
+    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;
@@ -528,31 +730,37 @@ 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
-  });
 }
 
-export { estimateFee, getBlockHeight, HttpRequestError, getMapEntry, getNonce, extendedApiSource, indexTxSource, TransactionError, BroadcastError, TransactionAbortedError, TransactionDroppedError, WaitForTransactionTimeoutError, SerializationError, SigningError, waitForTransactionReceipt, sendTransaction, jsonRpcSource, memoryStore, createNonceManager, resolveNonce, reconcileNonce, startNonceReconciler, isNonceConflictError, broadcastWithNonceReset, isProviderAccount, isFeeTier, minimumFee, resolveFee, setUnsignedFee, assertNoFeeTierForProvider, callContract };
-
-//# debugId=822AF008FBCE784B64756E2164756E21
-//# sourceMappingURL=stacks-fb75yew8.js.map
+//# debugId=DC00E5DBCD8CE8AA64756E2164756E21
+//# sourceMappingURL=stacks-db3kwavg.cjs.map