@secondlayer/stacks 6.0.0 → 6.1.0

package/dist/shared/stacks-37kz5t9f.cjs

@@ -1,764 +0,0 @@
-// src/actions/public/estimateFee.ts
-function isValidEstimation(e) {
-  return typeof e === "object" && e !== null && "fee_rate" in e && "fee" in e && (typeof e.fee_rate === "number" || typeof e.fee_rate === "string") && (typeof e.fee === "number" || typeof e.fee === "string");
-}
-async function estimateFee(client, params) {
-  const payloadHex = bytesToHex(serializePayload(params.transaction.payload));
-  const txHex = bytesToHex(serializeTransaction(params.transaction));
-  const data = await client.request("/v2/fees/transaction", {
-    method: "POST",
-    body: {
-      estimated_len: Math.ceil(txHex.length / 2),
-      transaction_payload: `0x${payloadHex}`
-    }
-  });
-  const raw = data?.estimations ?? [];
-  return raw.map((e) => {
-    if (!isValidEstimation(e)) {
-      throw new MalformedResponseError("estimateFee: node response contains invalid fee estimation entry");
-    }
-    return {
-      feeRate: Number(e.fee_rate),
-      fee: Number(e.fee)
-    };
-  });
-}
-
-// src/actions/public/getBlockHeight.ts
-async function getBlockHeight(client) {
-  const data = await client.request("/v2/info", { method: "GET" });
-  if (typeof data?.stacks_tip_height !== "number") {
-    throw new MalformedResponseError('getBlockHeight: /v2/info response is missing "stacks_tip_height"');
-  }
-  return data.stacks_tip_height;
-}
-
-// src/errors/http.ts
-class HttpRequestError extends BaseError {
-  name = "HttpRequestError";
-  status;
-  url;
-  method;
-  constructor(status, options) {
-    const where = options?.url !== undefined ? ` (${options.method ?? "GET"} ${options.url})` : "";
-    super(`HTTP request failed with status ${status}${where}`, options);
-    this.status = status;
-    this.url = options?.url;
-    this.method = options?.method;
-  }
-}
-
-// src/actions/public/getMapEntry.ts
-async function getMapEntry(client, params) {
-  const [address, name] = parseContractId(params.contract);
-  const serializedKey = with0x(bytesToHex(serializeCVBytes(params.key)));
-  const data = await client.request(`/v2/map_entry/${address}/${name}/${params.mapName}`, {
-    method: "POST",
-    body: serializedKey
-  });
-  if (typeof data?.data !== "string") {
-    throw new MalformedResponseError(`getMapEntry: /v2/map_entry/${address}/${name}/${params.mapName} response is missing "data"`);
-  }
-  return deserializeCVBytes(data.data);
-}
-
-// src/actions/public/getNonce.ts
-async function getNonce(client, params) {
-  const data = await client.request(`/v2/accounts/${encodeURIComponent(params.address)}`, { method: "GET" });
-  const nonce = data?.nonce;
-  if (typeof nonce !== "number" && typeof nonce !== "string") {
-    throw new MalformedResponseError(`getNonce: /v2/accounts/${params.address} response is missing "nonce"`);
-  }
-  return BigInt(nonce);
-}
-
-// src/errors/transport.ts
-class TimeoutError extends BaseError {
-  name = "TimeoutError";
-  method;
-  url;
-  timeout;
-  attempt;
-  constructor(params) {
-    super(`${params.method} ${params.url} did not complete within ${params.timeout}ms (attempt ${params.attempt + 1})`);
-    this.method = params.method;
-    this.url = params.url;
-    this.timeout = params.timeout;
-    this.attempt = params.attempt;
-  }
-}
-
-// src/transports/createTransport.ts
-function createTransport(type, config) {
-  const { request, apiKey: _apiKey, ...exposed } = config;
-  return {
-    type,
-    request,
-    config: exposed
-  };
-}
-var MAX_ERROR_DETAILS_BYTES = 4096;
-function capDetails(body) {
-  if (body === undefined)
-    return;
-  const bytes = new TextEncoder().encode(body);
-  if (bytes.length <= MAX_ERROR_DETAILS_BYTES)
-    return body;
-  const head = new TextDecoder().decode(bytes.subarray(0, MAX_ERROR_DETAILS_BYTES));
-  return `${head}... [truncated ${bytes.length - MAX_ERROR_DETAILS_BYTES} bytes]`;
-}
-function isRetryableStatus(status) {
-  return status === 429 || status >= 500;
-}
-var MAX_RETRY_AFTER_MS = 60000;
-function retryAfterMs(response) {
-  const value = response.headers.get("Retry-After");
-  if (!value)
-    return;
-  const seconds = Number(value);
-  const ms = Number.isFinite(seconds) ? seconds * 1000 : Date.parse(value) - Date.now();
-  if (!Number.isFinite(ms) || ms < 0 || ms > MAX_RETRY_AFTER_MS)
-    return;
-  return ms;
-}
-function abortReason(signal) {
-  const reason = signal.reason;
-  if (reason instanceof Error)
-    return reason;
-  return new DOMException(typeof reason === "string" ? reason : "The operation was aborted", "AbortError");
-}
-function sleep(ms, signal) {
-  return new Promise((resolve, reject) => {
-    if (signal?.aborted)
-      return reject(abortReason(signal));
-    const onAbort = () => {
-      clearTimeout(id);
-      reject(abortReason(signal));
-    };
-    const id = setTimeout(() => {
-      signal?.removeEventListener("abort", onAbort);
-      resolve();
-    }, ms);
-    signal?.addEventListener("abort", onAbort, { once: true });
-  });
-}
-async function fetchWithRetry(url, options, retryCount, retryDelay, timeout, extra = {}) {
-  const { signal } = extra;
-  const read = extra.read ?? (async (response) => response);
-  const method = options.method ?? "GET";
-  let lastError;
-  for (let attempt = 0;attempt <= retryCount; attempt++) {
-    if (signal?.aborted)
-      throw abortReason(signal);
-    const controller = new AbortController;
-    let timedOut = false;
-    const timeoutId = setTimeout(() => {
-      timedOut = true;
-      controller.abort(new TimeoutError({ method, url, timeout, attempt }));
-    }, timeout);
-    const onCallerAbort = () => controller.abort(abortReason(signal));
-    signal?.addEventListener("abort", onCallerAbort, { once: true });
-    const aborted = new Promise((_, reject) => {
-      if (controller.signal.aborted)
-        return reject(controller.signal.reason);
-      controller.signal.addEventListener("abort", () => reject(controller.signal.reason), { once: true });
-    });
-    let response;
-    try {
-      try {
-        response = await Promise.race([
-          fetch(url, { ...options, signal: controller.signal }),
-          aborted
-        ]);
-      } catch (error) {
-        if (signal?.aborted)
-          throw abortReason(signal);
-        lastError = timedOut ? new TimeoutError({ method, url, timeout, attempt }) : error instanceof Error ? error : new Error(String(error));
-        if (attempt < retryCount) {
-          clearTimeout(timeoutId);
-          await sleep(retryDelay * (attempt + 1), signal);
-          continue;
-        }
-        throw lastError;
-      }
-      if (response.ok) {
-        try {
-          return await Promise.race([read(response), aborted]);
-        } catch (error) {
-          response.body?.cancel().catch(() => {});
-          if (signal?.aborted)
-            throw abortReason(signal);
-          if (!timedOut)
-            throw error;
-          lastError = new TimeoutError({ method, url, timeout, attempt });
-          if (attempt < retryCount) {
-            clearTimeout(timeoutId);
-            await sleep(retryDelay * (attempt + 1), signal);
-            continue;
-          }
-          throw lastError;
-        }
-      }
-      const retryable = isRetryableStatus(response.status);
-      if (!retryable || attempt === retryCount) {
-        const body = await Promise.race([
-          response.text().catch(() => {
-            return;
-          }),
-          aborted.catch(() => {
-            return;
-          })
-        ]);
-        throw new HttpRequestError(response.status, {
-          details: capDetails(body),
-          url,
-          method
-        });
-      }
-      lastError = new HttpRequestError(response.status, { url, method });
-      const delay = retryAfterMs(response) ?? retryDelay * (attempt + 1);
-      response.body?.cancel().catch(() => {});
-      clearTimeout(timeoutId);
-      await sleep(delay, signal);
-    } finally {
-      clearTimeout(timeoutId);
-      signal?.removeEventListener("abort", onCallerAbort);
-    }
-  }
-  throw lastError ?? new Error("Request failed");
-}
-async function readBody(response) {
-  const contentType = response.headers.get("content-type") ?? "";
-  if (contentType.includes("application/json")) {
-    return response.json();
-  }
-  return response.text();
-}
-function buildRequestFn(baseUrl, config) {
-  const {
-    timeout = 30000,
-    retryCount = 3,
-    retryDelay = 150,
-    fetchOptions = {},
-    apiKey
-  } = config;
-  return async (path, options) => {
-    const url = `${baseUrl.replace(/\/$/, "")}${path}`;
-    const headers = {
-      "Content-Type": "application/json",
-      ...fetchOptions.headers,
-      ...options?.headers
-    };
-    if (apiKey) {
-      headers["x-api-key"] = apiKey;
-    }
-    const init = {
-      ...fetchOptions,
-      method: options?.method ?? "GET",
-      headers
-    };
-    if (options?.body !== undefined) {
-      init.body = JSON.stringify(options.body);
-    }
-    return fetchWithRetry(url, init, options?.retryCount ?? retryCount, retryDelay, timeout, { signal: options?.signal, read: readBody });
-  };
-}
-
-// src/actions/public/txSources.ts
-class IndexSourceConfigError extends Error {
-  name = "IndexSourceConfigError";
-}
-function isHiroHost(url, client) {
-  let hostname;
-  try {
-    hostname = new URL(url).hostname;
-  } catch {
-    return false;
-  }
-  if (hostname === "hiro.so" || hostname.endsWith(".hiro.so"))
-    return true;
-  const defaults = client.chain?.rpcUrls?.default?.http ?? [];
-  return defaults.some((d) => {
-    try {
-      return new URL(d).hostname === hostname && hostname !== "localhost";
-    } catch {
-      return false;
-    }
-  });
-}
-function indexRequestFn(client, baseUrl, sourceName) {
-  const transportUrl = client.transport.config.url?.replace(/\/$/, "");
-  if (baseUrl === undefined) {
-    if (!transportUrl) {
-      throw new IndexSourceConfigError(`${sourceName} needs the URL of your Secondlayer instance: pass baseUrl, or use an http() transport pointed at the instance`);
-    }
-    if (isHiroHost(transportUrl, client)) {
-      throw new IndexSourceConfigError(`${sourceName} reads /v1/index on a Secondlayer instance, and ${transportUrl} is a Hiro host: pass baseUrl with the URL of your instance`);
-    }
-    return client.request;
-  }
-  const target = baseUrl.replace(/\/$/, "");
-  if (target === transportUrl)
-    return client.request;
-  const { timeout, retryCount, retryDelay } = client.transport.config;
-  return buildRequestFn(target, { timeout, retryCount, retryDelay });
-}
-function indexNotFound(error, sourceName) {
-  if (!(error instanceof HttpRequestError) || error.status !== 404) {
-    return false;
-  }
-  const body = error.details;
-  if (body !== undefined) {
-    try {
-      JSON.parse(body);
-    } catch {
-      throw new IndexSourceConfigError(`${sourceName} got a non-JSON 404 from ${error.url ?? "the transport host"}: it does not serve /v1/index, pass baseUrl with the URL of your Secondlayer instance`, { cause: error });
-    }
-  }
-  return true;
-}
-function normalizeTxid(txid) {
-  return txid.startsWith("0x") ? txid : `0x${txid}`;
-}
-function decodeResultHex(hex) {
-  if (!hex)
-    return {};
-  try {
-    return { result: deserializeCVBytes(hex), resultHex: hex };
-  } catch {
-    return { resultHex: hex };
-  }
-}
-function normalizeStatus(txStatus) {
-  switch (txStatus) {
-    case "pending":
-    case "success":
-    case "abort_by_response":
-    case "abort_by_post_condition":
-      return txStatus;
-    default:
-      return txStatus.startsWith("dropped") ? "dropped" : undefined;
-  }
-}
-function extendedApiSource() {
-  return {
-    async get({ client, txid }) {
-      let data;
-      try {
-        data = await client.request(`/extended/v1/tx/${encodeURIComponent(normalizeTxid(txid))}`, { method: "GET" });
-      } catch (error) {
-        if (error instanceof HttpRequestError && error.status === 404) {
-          return { receipt: null };
-        }
-        throw error;
-      }
-      const txStatus = typeof data?.tx_status === "string" ? data.tx_status : undefined;
-      if (!txStatus)
-        return { receipt: null };
-      const status = normalizeStatus(txStatus);
-      if (!status)
-        return { receipt: null };
-      return {
-        receipt: {
-          txid: normalizeTxid(txid),
-          status,
-          blockHeight: typeof data.block_height === "number" && data.block_height > 0 ? data.block_height : undefined,
-          blockHash: data.block_hash ?? undefined,
-          ...decodeResultHex(data.tx_result?.hex),
-          events: Array.isArray(data.events) ? data.events : [],
-          raw: data
-        }
-      };
-    }
-  };
-}
-function indexTxSource(params = {}) {
-  const headers = params.apiKey ? { authorization: `Bearer ${params.apiKey}` } : undefined;
-  return {
-    canonicalOnly: true,
-    async get({ client, txid }) {
-      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 tx = data.transaction;
-      const tip = data.tip?.block_height;
-      if (!tx)
-        return { receipt: null, tip };
-      const status = normalizeStatus(tx.status) ?? "success";
-      return {
-        receipt: {
-          txid: normalizeTxid(tx.tx_id),
-          status,
-          blockHeight: tx.block_height,
-          ...decodeResultHex(tx.contract_call?.result_hex),
-          events: [],
-          raw: data
-        },
-        tip
-      };
-    }
-  };
-}
-
-// src/actions/public/getTransaction.ts
-async function getTransaction(client, params) {
-  const source = params.source ?? extendedApiSource();
-  const { receipt } = await source.get({ client, txid: params.txid });
-  return receipt;
-}
-
-// src/actions/public/waitForTransactionReceipt.ts
-var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
-async function waitForTransactionReceipt(client, params) {
-  const {
-    txid,
-    confirmations = 1,
-    timeout = 180000,
-    pollingInterval = 3000
-  } = params;
-  const source = params.source ?? extendedApiSource();
-  const droppedGracePeriod = params.droppedGracePeriod ?? (source.canonicalOnly ? timeout : 30000);
-  const startedAt = Date.now();
-  let unknownSince = null;
-  let everPending = false;
-  while (true) {
-    const snapshot = await source.get({ client, txid });
-    const receipt = snapshot.receipt;
-    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 });
-      }
-    } else {
-      unknownSince = null;
-      switch (receipt.status) {
-        case "dropped":
-          throw new TransactionDroppedError(`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 });
-        case "pending":
-          everPending = true;
-          break;
-        case "success": {
-          if (confirmations <= 1)
-            return receipt;
-          if (receipt.blockHeight !== undefined) {
-            const tip = snapshot.tip ?? await getBlockHeight(client);
-            if (tip - receipt.blockHeight + 1 >= confirmations)
-              return receipt;
-          }
-          break;
-        }
-      }
-    }
-    if (Date.now() - startedAt >= timeout) {
-      throw new WaitForTransactionTimeoutError(`Timed out after ${timeout}ms waiting for transaction ${txid}`, { txid });
-    }
-    await sleep2(pollingInterval);
-  }
-}
-
-// src/actions/wallet/sendTransaction.ts
-async function sendTransaction(client, params) {
-  const hex = bytesToHex(serializeTransaction(params.transaction));
-  const body = { tx: hex };
-  if (params.attachment) {
-    body.attachment = typeof params.attachment === "string" ? params.attachment : bytesToHex(params.attachment);
-  }
-  let data;
-  try {
-    data = await client.request("/v2/transactions", {
-      method: "POST",
-      body,
-      retryCount: 0
-    });
-  } catch (error) {
-    if (error instanceof HttpRequestError && error.details) {
-      try {
-        data = JSON.parse(error.details);
-      } catch {
-        throw error;
-      }
-    } else if (error instanceof TimeoutError) {
-      const txid2 = getTransactionId(params.transaction);
-      const receipt = await getTransaction(client, { txid: txid2 }).catch(() => null);
-      if (receipt === null)
-        throw error;
-      data = { txid: txid2 };
-    } else {
-      throw error;
-    }
-  }
-  if (data.error) {
-    throw new BroadcastError(data.reason ?? data.error, {
-      reason: data.reason,
-      reasonData: data.reason_data,
-      txid: data.txid ?? getTransactionId(params.transaction)
-    });
-  }
-  const txid = typeof data === "string" ? data.replace(/"/g, "") : data.txid ?? getTransactionId(params.transaction);
-  if (params.wait) {
-    const confirmations = params.wait === true ? 1 : params.wait;
-    const receipt = await waitForTransactionReceipt(client, {
-      txid,
-      confirmations
-    });
-    return { txid, receipt };
-  }
-  return { txid };
-}
-
-// src/actions/wallet/nonceManager.ts
-function jsonRpcSource() {
-  return {
-    get: ({ client, address }) => getNonce(client, { address })
-  };
-}
-function memoryStore() {
-  const next = new Map;
-  const locks = new Map;
-  function withLock(key, fn) {
-    const prev = locks.get(key) ?? Promise.resolve();
-    const run = prev.then(fn, fn);
-    locks.set(key, run.catch(() => {}));
-    return run;
-  }
-  return {
-    reserve(key, getFloor) {
-      return withLock(key, async () => {
-        let current = next.get(key);
-        if (current === undefined)
-          current = await getFloor();
-        next.set(key, current + 1n);
-        return current;
-      });
-    },
-    reset(key) {
-      next.delete(key);
-    },
-    release(key, nonce) {
-      return withLock(key, async () => {
-        if (next.get(key) === nonce + 1n)
-          next.set(key, nonce);
-      });
-    },
-    peek(key) {
-      return next.get(key);
-    }
-  };
-}
-function nonceKey(client, address) {
-  return `${client.chain?.id ?? "stacks"}:${address}`;
-}
-function createNonceManager(params = {}) {
-  const source = params.source ?? jsonRpcSource();
-  const store = params.store ?? memoryStore();
-  return {
-    consume({ client, address }) {
-      return store.reserve(nonceKey(client, address), () => source.get({ client, address }));
-    },
-    reset({ client, address }) {
-      return store.reset(nonceKey(client, address));
-    },
-    release({ client, address, nonce }) {
-      return store.release?.(nonceKey(client, address), nonce);
-    },
-    async peek({ client, address }) {
-      return store.peek?.(nonceKey(client, address));
-    }
-  };
-}
-async function resolveNonce(client, address) {
-  if (client.nonceManager)
-    return client.nonceManager.consume({ client, address });
-  return getNonce(client, { address });
-}
-async function releaseNonce(client, address, nonce) {
-  if (!client.nonceManager)
-    return;
-  try {
-    await client.nonceManager.release({ client, address, nonce });
-  } catch {}
-}
-async function reconcileNonce(manager, params) {
-  const { client, address, source } = params;
-  const downward = params.downward ?? true;
-  const authoritative = await source.get({ client, address });
-  const tracked = await manager.peek({ client, address });
-  if (tracked === undefined || authoritative === tracked) {
-    return { reset: false, authoritative, tracked };
-  }
-  if (authoritative < tracked && !downward) {
-    return { reset: false, authoritative, tracked };
-  }
-  await manager.reset({ client, address });
-  return { reset: true, authoritative, tracked };
-}
-function startNonceReconciler(manager, params) {
-  const { client, addresses, source, clock } = params;
-  const intervalMs = params.intervalMs ?? 60000;
-  let running = true;
-  const tick = async () => {
-    if (!running)
-      return;
-    for (const address of addresses) {
-      try {
-        const result = await reconcileNonce(manager, {
-          client,
-          address,
-          source,
-          downward: params.downward
-        });
-        params.onReconcile?.(address, result);
-      } catch (error) {
-        try {
-          params.onError?.(address, error);
-        } catch {}
-      }
-    }
-    if (running && clock) {
-      await clock.advance(intervalMs);
-      tick();
-    }
-  };
-  if (clock) {
-    tick();
-    return {
-      stop: () => {
-        running = false;
-      }
-    };
-  }
-  const timer = setInterval(tick, intervalMs);
-  timer.unref?.();
-  return {
-    stop: () => clearInterval(timer)
-  };
-}
-function isNonceConflictError(error) {
-  if (!(error instanceof BroadcastError))
-    return false;
-  if (error.reason === "ConflictingNonceInMempool" || error.reason === "BadNonce") {
-    return true;
-  }
-  if (error.reason !== undefined)
-    return false;
-  return error.message.toLowerCase().includes("nonce");
-}
-async function broadcastWithNonceReset(client, params) {
-  try {
-    const result = await sendTransaction(client, {
-      transaction: params.transaction
-    });
-    return result.txid;
-  } catch (error) {
-    if (client.nonceManager && isNonceConflictError(error)) {
-      await client.nonceManager.reset({ client, address: params.address });
-    }
-    throw error;
-  }
-}
-
-// src/actions/wallet/utils.ts
-function isProviderAccount(account) {
-  return account.type === "provider";
-}
-var FEE_TIERS = ["min", "low", "mid", "high"];
-var TIER_INDEX = { low: 0, mid: 1, high: 2 };
-function isFeeTier(fee) {
-  return typeof fee === "string" && FEE_TIERS.includes(fee);
-}
-function minimumFee(transaction) {
-  return BigInt(serializeTransaction(transaction).length);
-}
-function isNoEstimateAvailable(error) {
-  return error instanceof HttpRequestError && error.status === 400 && (error.details?.includes("NoEstimateAvailable") ?? false);
-}
-async function resolveFee(client, transaction, fee) {
-  if (fee !== undefined && !isFeeTier(fee))
-    return { fee: intToBigInt(fee) };
-  const tier = fee ?? "mid";
-  if (tier === "min")
-    return { fee: minimumFee(transaction), tier };
-  let estimates;
-  try {
-    estimates = await estimateFee(client, { transaction });
-  } catch (error) {
-    if (!isNoEstimateAvailable(error))
-      throw error;
-    return { fee: minimumFee(transaction), tier: "min" };
-  }
-  const pick = estimates[TIER_INDEX[tier]] ?? estimates[estimates.length - 1];
-  if (pick)
-    return { fee: BigInt(pick.fee), tier };
-  return { fee: minimumFee(transaction), tier: "min" };
-}
-function setUnsignedFee(transaction, fee) {
-  transaction.auth.spendingCondition.fee = fee;
-  clearTxCache(transaction);
-}
-function assertNoFeeTierForProvider(fee) {
-  if (isFeeTier(fee)) {
-    throw new Error(`Fee tier '${fee}' requires local signing; provider (wallet) accounts set their own fee`);
-  }
-}
-
-// src/actions/wallet/callContract.ts
-async function callContract(client, params) {
-  const account = client.account;
-  if (!account)
-    throw new Error("Account required");
-  const [contractAddress, contractName] = parseContractId(params.contract);
-  if (isProviderAccount(account)) {
-    assertNoFeeTierForProvider(params.fee);
-    const result = await account.provider.request("stx_callContract", {
-      contract: params.contract,
-      functionName: params.functionName,
-      functionArgs: params.functionArgs ?? []
-    });
-    return result.txid;
-  }
-  const managed = params.nonce === undefined && client.nonceManager !== undefined;
-  const nonce = params.nonce ?? await resolveNonce(client, account.address);
-  try {
-    const needsFeeResolution = params.fee === undefined || isFeeTier(params.fee);
-    const unsigned = buildContractCall({
-      contractAddress,
-      contractName,
-      functionName: params.functionName,
-      functionArgs: params.functionArgs ?? [],
-      fee: needsFeeResolution ? 0n : params.fee,
-      nonce,
-      publicKey: account.publicKey,
-      chain: client.chain,
-      postConditionMode: params.postConditionMode,
-      postConditions: params.postConditions
-    });
-    if (needsFeeResolution) {
-      const { fee } = await resolveFee(client, unsigned, params.fee);
-      setUnsignedFee(unsigned, fee);
-    }
-    const signed = await signTransactionWithAccount(unsigned, account);
-    return await broadcastWithNonceReset(client, {
-      transaction: signed,
-      address: account.address
-    });
-  } catch (error) {
-    if (managed)
-      await releaseNonce(client, account.address, nonce);
-    throw error;
-  }
-}
-
-//# debugId=C746B6AF7E1C8C7C64756E2164756E21
-//# sourceMappingURL=stacks-37kz5t9f.cjs.map