@secondlayer/stacks 2.11.0 → 2.13.0

package/dist/src/tools/index.cjs

@@ -41,7 +41,7 @@ var __export = (target, all) => {
 var exports_tools = {};
 __export(exports_tools, {
   readContract: () => readContract2,
-  getTransaction: () => getTransaction,
+  getTransaction: () => getTransaction2,
   getStxBalance: () => getStxBalance,
   getNftHoldings: () => getNftHoldings,
   getMempoolStats: () => getMempoolStats,
@@ -1489,10 +1489,39 @@ 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;
   }
 }
 
@@ -1508,6 +1537,107 @@ async function getNonce(client, params) {
   return BigInt(nonce);
 }
 
+// src/actions/public/txSources.ts
+function normalizeTxid(txid2) {
+  return txid2.startsWith("0x") ? txid2 : `0x${txid2}`;
+}
+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: txid2 }) {
+      const data = await client.request(`/extended/v1/tx/${normalizeTxid(txid2)}`, { method: "GET" });
+      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(txid2),
+          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
+        }
+      };
+    }
+  };
+}
+
+// src/actions/public/waitForTransactionReceipt.ts
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function waitForTransactionReceipt(client, params) {
+  const {
+    txid: txid2,
+    confirmations = 1,
+    timeout = 180000,
+    pollingInterval = 3000,
+    droppedGracePeriod = 30000
+  } = params;
+  const source = params.source ?? extendedApiSource();
+  const startedAt = Date.now();
+  let unknownSince = null;
+  let everPending = false;
+  while (true) {
+    const snapshot = await source.get({ client, txid: txid2 });
+    const receipt = snapshot.receipt;
+    if (receipt === null) {
+      unknownSince ??= Date.now();
+      if (Date.now() - unknownSince >= droppedGracePeriod) {
+        throw new TransactionDroppedError(everPending ? `Transaction ${txid2} left the mempool without being mined` : `Transaction ${txid2} was never observed by the status source`, { txid: txid2 });
+      }
+    } else {
+      unknownSince = null;
+      switch (receipt.status) {
+        case "dropped":
+          throw new TransactionDroppedError(`Transaction ${txid2} was dropped from the mempool`, { txid: txid2 });
+        case "abort_by_response":
+        case "abort_by_post_condition":
+          throw new TransactionAbortedError(`Transaction ${txid2} 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 ${txid2}`, { txid: txid2 });
+    }
+    await sleep(pollingInterval);
+  }
+}
+
 // src/actions/wallet/sendTransaction.ts
 async function sendTransaction(client, params) {
   const hex = bytesToHex(serializeTransaction(params.transaction));
@@ -1521,10 +1651,20 @@ async function sendTransaction(client, params) {
   });
   if (data.error) {
     throw new BroadcastError(data.reason ?? data.error, {
-      reason: data.reason
+      reason: data.reason,
+      reasonData: data.reason_data,
+      txid: data.txid ?? getTransactionId(params.transaction)
     });
   }
   const txid2 = 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: txid2,
+      confirmations
+    });
+    return { txid: txid2, receipt };
+  }
   return { txid: txid2 };
 }
 
@@ -1537,8 +1677,12 @@ async function resolveNonce(client, address) {
 function isNonceConflictError(error) {
   if (!(error instanceof BroadcastError))
     return false;
-  const haystack = `${error.reason ?? ""} ${error.message}`.toLowerCase();
-  return haystack.includes("nonce");
+  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 {
@@ -1558,6 +1702,36 @@ async function broadcastWithNonceReset(client, params) {
 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;
+}
+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) {
@@ -1566,6 +1740,7 @@ async function callContract(client, params) {
     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,
@@ -1574,24 +1749,21 @@ async function callContract(client, params) {
     return result.txid;
   }
   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: params.fee ?? 0n,
+    fee: needsFeeResolution ? 0n : params.fee,
     nonce,
     publicKey: account.publicKey,
     chain: client.chain,
     postConditionMode: params.postConditionMode,
     postConditions: params.postConditions
   });
-  if (params.fee === undefined) {
-    const estimates = await estimateFee(client, { transaction: unsigned });
-    const mid = estimates[1] ?? estimates[0];
-    if (mid) {
-      unsigned.auth.spendingCondition.fee = BigInt(mid.fee);
-    }
+  if (needsFeeResolution) {
+    setUnsignedFee(unsigned, await resolveFee(client, unsigned, params.fee));
   }
   const signed = await signTransactionWithAccount(unsigned, account);
   return broadcastWithNonceReset(client, {
@@ -2411,6 +2583,13 @@ async function getContractAbi(client, params) {
   });
 }
 
+// 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/multicall.ts
 async function multicall(client, params) {
   const { calls, allowFailure = true } = params;
@@ -2561,6 +2740,8 @@ function publicActions(client) {
     multicall: (params) => multicall(client, params),
     simulateCall: (params) => simulateCall(client, params),
     simulateTransaction: (params) => simulateTransaction(client, params),
+    getTransaction: (params) => getTransaction(client, params),
+    waitForTransactionReceipt: (params) => waitForTransactionReceipt(client, params),
     watchBlocks: (params) => watchBlocks(client, params),
     watchMempool: (params) => watchMempool(client, params),
     watchTransaction: (params) => watchTransaction(client, params),
@@ -2869,7 +3050,7 @@ var bnsReverse = import_ai.tool({
   inputSchema: import_zod.z.object({ principal: PRINCIPAL }),
   execute: ({ principal }) => bnsReverseImpl(getDefaultPublicClient(), principal)
 });
-var getTransaction = import_ai.tool({
+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)
@@ -2896,5 +3077,5 @@ var getNftHoldings = import_ai.tool({
   execute: ({ principal, limit }) => nftHoldings(getDefaultPublicClient(), principal, limit)
 });
 
-//# debugId=47021AD178AA414364756E2164756E21
+//# debugId=E0CFA9E2C0C074CF64756E2164756E21
 //# sourceMappingURL=index.cjs.map