alkanesjs 1.1.8 → 1.2.0

package/dist/index.browser.mjs

@@ -47226,19 +47226,21 @@ var ProtostoneTransactionWithInscription = class {
         commitTxInput.index
       )
     };
-    const dry = await getDummyProtostoneTransaction(this.changeAddress, {
+    let dry = await getDummyProtostoneTransaction(this.changeAddress, {
       ...this.opts,
       includeInputs: [commitTxInputOption],
       availableUtxoTweak: this.utxoTweak,
-      feeRate: this.baseFeeRate + 2
+      feeRate: this.baseFeeRate + 1
     });
     if (isBoxedError(dry)) throw new Error(dry.message);
+    const witnessWeight = this.script.length * 1;
+    dry.data.feeOpts.vsize += Math.ceil(witnessWeight / 4);
     this.revealBuilder = new ProtostoneTransaction(this.changeAddress, {
       ...this.opts,
       includeInputs: [commitTxInputOption],
       availableUtxoTweak: this.utxoTweak,
       feeOpts: dry.data.feeOpts,
-      feeRate: this.baseFeeRate + 2
+      feeRate: this.baseFeeRate + 1
     });
     await this.revealBuilder.build();
     this.revealPsbt = this.revealBuilder.getPsbt();
@@ -52646,64 +52648,67 @@ var ElectrumApiProvider = class {
       );
     }
   }
+  async esplora_getbulktransactions(transactionIds) {
+    try {
+      const requestUrl = `${this.electrumApiUrl}/txs`;
+      const httpResponse = await fetch(requestUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ txs: transactionIds })
+      });
+      if (!httpResponse.ok) {
+        return new BoxedError(
+          "UnknownError" /* UnknownError */,
+          `Failed to fetch transactions from ${requestUrl}: ${httpResponse.statusText}`
+        );
+      }
+      const transactions = await httpResponse.json();
+      return new BoxedSuccess(transactions);
+      const txs = await Promise.all(
+        transactionIds.map((txid) => this.esplora_gettransaction(txid))
+      );
+    } catch (error) {
+      return new BoxedError(
+        "UnknownError" /* UnknownError */,
+        `Failed to fetch bulk transactions: ${error.message}`
+      );
+    }
+  }
   /*
     async esplora_getbulktransactions(
       transactionIds: string[],
     ): Promise<BoxedResponse<IEsploraTransaction[], EsploraFetchError>> {
       try {
-        const requestUrl = `${this.electrumApiUrl}/txs`;
+        const allTxs: IEsploraTransaction[] = [];
   
-        const httpResponse = await fetch(requestUrl, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ txs: transactionIds }),
-        });
+        // ‑‑ process in batches of 10 ------------------------------------------------
+        for (let i = 0; i < transactionIds.length; i += 10) {
+          const batch = transactionIds.slice(i, i + 10);
   
-        if (!httpResponse.ok) {
-          return new BoxedError(
-            EsploraFetchError.UnknownError,
-            `Failed to fetch transactions from ${requestUrl}: ${httpResponse.statusText}`,
+          // run the 10 requests in parallel
+          const batchResponses = await Promise.all(
+            batch.map((txid) => this.esplora_gettransaction(txid)),
           );
-        }
   
-        const transactions = (await httpResponse.json()) as IEsploraTransaction[];
-        return new BoxedSuccess(transactions);
-        
   
-        const txs = await Promise.all(
-          transactionIds.map((txid) => this.esplora_gettransaction(txid)),
-        );
+          const batchTxs = consumeAll(batchResponses); // IEsploraTransaction[]
+          allTxs.push(...batchTxs);
+        }
   
+        return new BoxedSuccess(allTxs);
       } catch (error) {
+        // if consumeAll returns/throws a BoxedError we land here ⬇
+        if (error instanceof BoxedError) {
+          return error;
+        }
+  
         return new BoxedError(
           EsploraFetchError.UnknownError,
           `Failed to fetch bulk transactions: ${(error as Error).message}`,
         );
       }
     }
-      */
-  async esplora_getbulktransactions(transactionIds) {
-    try {
-      const allTxs = [];
-      for (let i = 0; i < transactionIds.length; i += 10) {
-        const batch = transactionIds.slice(i, i + 10);
-        const batchResponses = await Promise.all(
-          batch.map((txid) => this.esplora_gettransaction(txid))
-        );
-        const batchTxs = consumeAll(batchResponses);
-        allTxs.push(...batchTxs);
-      }
-      return new BoxedSuccess(allTxs);
-    } catch (error) {
-      if (error instanceof BoxedError) {
-        return error;
-      }
-      return new BoxedError(
-        "UnknownError" /* UnknownError */,
-        `Failed to fetch bulk transactions: ${error.message}`
-      );
-    }
-  }
+    */
   async esplora_gettransaction(transactionId) {
     try {
       const requestUrl = `${this.electrumApiUrl}/tx/${transactionId}`;