alkanesjs 1.2.0 → 1.2.2

package/dist/index.browser.mjs

@@ -47368,7 +47368,8 @@ var ProtostoneTransaction = class {
     this.fee = Math.max(baseFee, this.MINIMUM_FEE);
   }
   calcCumulativeSpendRequirements() {
-    this.cumulativeSpendRequirementBtc = this.fee + this.MINIMUM_PROTOCOL_DUST * 2;
+    this.cumulativeSpendRequirementBtc = this.fee + this.MINIMUM_PROTOCOL_DUST * (this.transactionOptions.transfers?.length ?? 0) + this.MINIMUM_PROTOCOL_DUST;
+    console.log(this.cumulativeSpendRequirementBtc);
     this.cumulativeSpendRequirementAlkanes = this.transactionOptions.transfers.reduce(
       (acc, transfer) => {
         if (isBTCTransfer(transfer)) {
@@ -47596,7 +47597,7 @@ var ProtostoneTransaction = class {
         ),
         // Convert bigint to string for JSON compatibility
         amount: (0, import_integer.u128)(transfer.amount),
-        output: (0, import_integer.u32)(outputIds[address3] + (hasChange ? 1 : 0))
+        output: (0, import_integer.u32)(outputIds[address3] + 1)
       };
       if (!alkanesEdicts[address3]) {
         alkanesEdicts[address3] = {};
@@ -47616,6 +47617,7 @@ var ProtostoneTransaction = class {
         output: edict.output
       }))
     );
+    console.log(transactionEdicts[0]);
     return transactionEdicts;
   }
   addProtostoneData(edicts) {
@@ -52674,6 +52676,53 @@ var ElectrumApiProvider = class {
       );
     }
   }
+  async esplora_getblocktiphash() {
+    try {
+      const requestUrl = `${this.electrumApiUrl}/blocks/tip/hash`;
+      const httpResponse = await fetch(requestUrl);
+      if (!httpResponse.ok) {
+        return new BoxedError(
+          "UnknownError" /* UnknownError */,
+          `Failed to fetch tip hash from ${requestUrl}: ${httpResponse.statusText}`
+        );
+      }
+      const tipHash = (await httpResponse.text()).trim();
+      return new BoxedSuccess(tipHash);
+    } catch (error) {
+      return new BoxedError(
+        "UnknownError" /* UnknownError */,
+        `Failed to fetch tip hash: ${error.message}`
+      );
+    }
+  }
+  async _esplora_getrawblock(blockHash) {
+    try {
+      const requestUrl = `${this.electrumApiUrl}/block/${blockHash}/raw`;
+      const httpResponse = await fetch(requestUrl);
+      if (!httpResponse.ok) {
+        return new BoxedError(
+          "UnknownError" /* UnknownError */,
+          `Failed to fetch raw block ${blockHash} from ${requestUrl}: ${httpResponse.statusText}`
+        );
+      }
+      const bytes3 = new Uint8Array(await httpResponse.arrayBuffer());
+      const rawHex = Array.from(
+        bytes3,
+        (b) => b.toString(16).padStart(2, "0")
+      ).join("");
+      return new BoxedSuccess("0x" + rawHex);
+    } catch (error) {
+      return new BoxedError(
+        "UnknownError" /* UnknownError */,
+        `Failed to fetch raw block ${blockHash}: ${error.message}`
+      );
+    }
+  }
+  async esplora_getrawblocktip() {
+    const tipHashResponse = await this.esplora_getblocktiphash();
+    if (isBoxedError(tipHashResponse)) return tipHashResponse;
+    return this._esplora_getrawblock(tipHashResponse.data);
+  }
   /*
     async esplora_getbulktransactions(
       transactionIds: string[],
@@ -55209,6 +55258,42 @@ init_shim();
 init_process();
 init_buffer();
 var stripHex = (s) => s.startsWith("0x") ? s.slice(2) : s;
+function toU64LittleEndianHex(numStr) {
+  const num2 = BigInt(numStr);
+  const hex4 = num2.toString(16).padStart(16, "0");
+  const bytes3 = hex4.match(/.{2}/g);
+  if (!bytes3) throw new Error("Invalid hex conversion");
+  const littleEndian = bytes3.reverse().join("");
+  return `0x${littleEndian}`;
+}
+function makeFakeBlock(height) {
+  const buf = new Uint8Array(80);
+  const h = BigInt(height);
+  for (let i = 0; i < 8; i++) {
+    buf[72 + i] = Number(h >> BigInt(8 * i) & 0xffn);
+  }
+  const hex4 = Array.from(buf, (b) => b.toString(16).padStart(2, "0")).join("");
+  return `${hex4}`;
+}
+function toU64BigEndianHex(numStr) {
+  const MAX_U64 = BigInt("0xffffffffffffffff");
+  const num2 = BigInt(numStr);
+  if (num2 < 0n || num2 > MAX_U64) {
+    throw new RangeError("Value exceeds u64 range");
+  }
+  const hex4 = num2.toString(16).padStart(16, "0");
+  return `0x${hex4}`;
+}
+function toU128LittleEndianHex(numStr) {
+  const MAX_U1282 = BigInt("0xffffffffffffffffffffffffffffffff");
+  const num2 = BigInt(numStr);
+  if (num2 < 0n || num2 > MAX_U1282) {
+    throw new RangeError("Value exceeds u128 range");
+  }
+  const hex4 = num2.toString(16).padStart(32, "0");
+  const littleEndian = hex4.match(/.{2}/g).reverse().join("");
+  return `0x${littleEndian}`;
+}
 function mapToPrimitives(v) {
   switch (typeof v) {
     case "bigint":
@@ -55217,7 +55302,9 @@ function mapToPrimitives(v) {
       if (v === null) return null;
       if (Buffer3.isBuffer(v)) return "0x" + v.toString("hex");
       if (Array.isArray(v)) return v.map(mapToPrimitives);
-      return Object.fromEntries(Object.entries(v).map(([k, val]) => [k, mapToPrimitives(val)]));
+      return Object.fromEntries(
+        Object.entries(v).map(([k, val]) => [k, mapToPrimitives(val)])
+      );
     }
     default:
       return v;
@@ -55226,13 +55313,16 @@ function mapToPrimitives(v) {
 function unmapFromPrimitives(v) {
   switch (typeof v) {
     case "string":
-      if (v.startsWith("0x") && v !== "0x") return Buffer3.from(stripHex(v), "hex");
+      if (v.startsWith("0x") && v !== "0x")
+        return Buffer3.from(stripHex(v), "hex");
       if (!isNaN(v)) return BigInt(v);
       return v;
     case "object": {
       if (v === null) return null;
       if (Array.isArray(v)) return v.map(unmapFromPrimitives);
-      return Object.fromEntries(Object.entries(v).map(([k, val]) => [k, unmapFromPrimitives(val)]));
+      return Object.fromEntries(
+        Object.entries(v).map(([k, val]) => [k, unmapFromPrimitives(val)])
+      );
     }
     default:
       return v;
@@ -55242,7 +55332,9 @@ function parseSimulateReturn(v) {
   if (v === "0x") return void 0;
   const toUtf8 = Buffer3.from(stripHex(v), "hex").toString("utf8");
   const isUtf8 = !/[\uFFFD]/.test(toUtf8);
-  const rev = Buffer3.from(Array.from(Buffer3.from(stripHex(v), "hex")).reverse()).toString("hex");
+  const rev = Buffer3.from(
+    Array.from(Buffer3.from(stripHex(v), "hex")).reverse()
+  ).toString("hex");
   return {
     string: isUtf8 ? toUtf8 : "0x" + stripHex(v),
     bytes: "0x" + stripHex(v),
@@ -55364,6 +55456,7 @@ var AlkanesRpcProvider = class {
       payload: ["alkanes_trace", [{ txid: leTxid, vout }]],
       call: async () => {
         try {
+          await this.provider.pacer.waitForPacer();
           const encoded = consumeOrThrow(
             await this.rpc("alkanes_trace", [
               { txid: leTxid, vout }
@@ -55435,14 +55528,12 @@ var AlkanesRpcProvider = class {
     ]);
   }
   async alkanes_simulate(req) {
-    const currentHeight = consumeOrThrow(
-      await this.alkanes_metashrewHeight().call()
-    );
+    await this.provider.pacer.waitForPacer();
     const merged = {
       alkanes: req.alkanes ?? [],
       transaction: req.transaction ?? "0x",
       block: "0x",
-      height: req.height ?? currentHeight,
+      height: "908474",
       txindex: req.txindex ?? 0,
       target: {
         block: req.target?.block?.toString() ?? "0",
@@ -55453,6 +55544,7 @@ var AlkanesRpcProvider = class {
       refundPointer: req.refundPointer ?? 0,
       vout: req.vout ?? 0
     };
+    console.log(merged);
     const res = await this.rpc(
       "alkanes_simulate",
       [merged]
@@ -55825,19 +55917,91 @@ var schemaAlkaneId = import_borsher4.BorshSchema.Struct({
 init_shim();
 init_process();
 init_buffer();
+
+// src/pacer.ts
+init_shim();
+init_process();
+init_buffer();
+var WaitPacer = class {
+  constructor(opts) {
+    __publicField(this, "maxPerInterval");
+    __publicField(this, "intervalMs");
+    __publicField(this, "minGapMs");
+    // track start times within the sliding window
+    __publicField(this, "starts", []);
+    __publicField(this, "lastStart", 0);
+    // serialize callers so their start times are paced correctly
+    __publicField(this, "tail", Promise.resolve());
+    this.maxPerInterval = Math.max(1, opts.maxPerInterval);
+    this.intervalMs = Math.max(1, opts.intervalMs);
+    this.minGapMs = Math.floor(this.intervalMs / this.maxPerInterval);
+  }
+  setRate(maxPerInterval, intervalMs) {
+    this.maxPerInterval = Math.max(1, maxPerInterval);
+    this.intervalMs = Math.max(1, intervalMs);
+    this.minGapMs = Math.floor(this.intervalMs / this.maxPerInterval);
+  }
+  now() {
+    return Date.now();
+  }
+  sleep(ms) {
+    return ms > 0 ? new Promise((r) => setTimeout(r, ms)) : Promise.resolve();
+  }
+  pruneWindow(now) {
+    const cutoff = now - this.intervalMs;
+    while (this.starts.length && this.starts[0] <= cutoff) this.starts.shift();
+  }
+  /** Await this immediately before the call that could rate-limit */
+  waitForPacer() {
+    const ticket = this.tail.then(async () => {
+      while (true) {
+        const now = this.now();
+        this.pruneWindow(now);
+        if (this.starts.length >= this.maxPerInterval) {
+          const earliest = this.starts[0];
+          const waitUntil = earliest + this.intervalMs;
+          await this.sleep(Math.max(0, waitUntil - this.now()));
+          continue;
+        }
+        const earliestStart = this.lastStart + this.minGapMs;
+        const delay = Math.max(0, earliestStart - now);
+        if (delay > 0) {
+          await this.sleep(delay);
+          continue;
+        }
+        const startTs = this.now();
+        this.lastStart = startTs;
+        this.starts.push(startTs);
+        break;
+      }
+    });
+    this.tail = ticket.catch(() => {
+    });
+    return ticket;
+  }
+};
+
+// src/provider.ts
 var Provider = class {
-  // 5 seconds
   constructor(config3) {
     __publicField(this, "sandshrewUrl");
     __publicField(this, "electrumApiUrl");
     __publicField(this, "network");
     __publicField(this, "explorerUrl");
+    __publicField(this, "pacerSettings", {
+      intervalMs: 1e3,
+      maxPerInterval: 10
+    });
     __publicField(this, "btcTicker");
+    __publicField(this, "jitterMs", 1e3);
+    // 1 second
     __publicField(this, "rpc");
     __publicField(this, "defaultFeeRate");
     __publicField(this, "TIMEOUT_MS", 6e4 * 5);
     // 5 minutes
     __publicField(this, "INTERVAL_MS", 5e3);
+    // 5 seconds
+    __publicField(this, "pacer");
     __publicField(this, "waitForBlocks", async (amount) => {
       try {
         let initialBlockCount = Number(
@@ -55929,8 +56093,10 @@ var Provider = class {
     this.network = config3.network;
     this.explorerUrl = config3.explorerUrl.replace(/\/+$/, "");
     this.btcTicker = config3.btcTicker ?? "BTC";
+    this.pacerSettings = config3.pacerSettings ?? this.pacerSettings;
     this.defaultFeeRate = config3.defaultFeeRate ?? 5;
     this.rpc = new BaseRpcProvider(this);
+    this.pacer = new WaitPacer(this.pacerSettings);
   }
   txUrl(txid) {
     return `${this.explorerUrl}/tx/${txid}`;
@@ -56039,6 +56205,7 @@ export {
   getProtostoneUnsignedPsbtBase64,
   getVSize,
   hexToUint8Array,
+  makeFakeBlock,
   mapToPrimitives,
   minimumFee,
   parseSimulateReturn,
@@ -56052,6 +56219,9 @@ export {
   tapTweakHash,
   toEsploraTx,
   toFormattedUtxo,
+  toU128LittleEndianHex,
+  toU64BigEndianHex,
+  toU64LittleEndianHex,
   trimUndefined,
   tweakSigner,
   u128Schema,