@arkade-os/sdk 0.4.47 → 0.4.48

package/dist/{chunk-HHV5FPC6.cjs → chunk-EB3ALGTM.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunkL5ND2FJJ_cjs = require('./chunk-L5ND2FJJ.cjs');
+var chunk7TXSPRN5_cjs = require('./chunk-7TXSPRN5.cjs');
 var chunk5BLDMQED_cjs = require('./chunk-5BLDMQED.cjs');
 var btcSigner = require('@scure/btc-signer');
 var secp256k1_js = require('@noble/curves/secp256k1.js');
@@ -136,7 +136,7 @@ var VtxoTreeExpiry = {
     if (!checkKeyMatch(unknown[0], "expiry" /* VtxoTreeExpiry */)) return null;
     const v = btcSigner.ScriptNum(6, true).decode(unknown[1]);
     if (!v) return null;
-    return chunkL5ND2FJJ_cjs.sequenceToTimelock(Number(v));
+    return chunk7TXSPRN5_cjs.sequenceToTimelock(Number(v));
   })
 };
 var encodedPsbtFieldKey = Object.fromEntries(
@@ -161,7 +161,7 @@ function checkKeyMatch(key, arkPsbtFieldKey, prefixOnly = false) {
 }
 
 // package.json
-var version = "0.4.47";
+var version = "0.4.48";
 
 // src/utils/fetch.ts
 var buildVersion = "0.9.9";
@@ -465,8 +465,8 @@ function prepareCoinAsIntentProofInput(coin) {
   if (!("tapTree" in coin)) {
     return coin;
   }
-  const vtxoScript = chunkL5ND2FJJ_cjs.VtxoScript.decode(coin.tapTree);
-  const sequence = chunkL5ND2FJJ_cjs.getSequence(coin.intentTapLeafScript);
+  const vtxoScript = chunk7TXSPRN5_cjs.VtxoScript.decode(coin.tapTree);
+  const sequence = chunk7TXSPRN5_cjs.getSequence(coin.intentTapLeafScript);
   const unknown = [VtxoTaprootTree.encode(coin.tapTree)];
   if (coin.extraWitness) {
     unknown.push(ConditionWitness.encode(coin.extraWitness));
@@ -584,6 +584,138 @@ function isEventSourceError(error) {
   return error instanceof Error && error.name === "EventSourceError";
 }
 
+// src/providers/rateGate.ts
+var DEFAULT_MAX_CONCURRENT = 6;
+var DEFAULT_COOLDOWN_MS = 5e3;
+var MAX_COOLDOWN_MS = 6e4;
+var DEFAULT_JITTER_MS = 500;
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function parseRetryAfterMs(header) {
+  if (header === null || header === void 0) return void 0;
+  const trimmed = header.trim();
+  if (trimmed === "") return void 0;
+  const seconds = Number(trimmed);
+  if (Number.isFinite(seconds)) return seconds < 0 ? void 0 : seconds * 1e3;
+  const at = Date.parse(trimmed);
+  if (!Number.isNaN(at)) return Math.max(0, at - Date.now());
+  return void 0;
+}
+function requestOrigin(input) {
+  let url;
+  if (typeof input === "string") {
+    url = input;
+  } else if (input instanceof URL) {
+    url = input.href;
+  } else {
+    url = input.url;
+  }
+  try {
+    return new URL(url).origin;
+  } catch {
+    return url;
+  }
+}
+var OriginRateGate = class {
+  states = /* @__PURE__ */ new Map();
+  maxConcurrent;
+  defaultCooldownMs;
+  maxCooldownMs;
+  jitterMs;
+  constructor(options) {
+    this.maxConcurrent = options?.maxConcurrent ?? DEFAULT_MAX_CONCURRENT;
+    this.defaultCooldownMs = options?.defaultCooldownMs ?? DEFAULT_COOLDOWN_MS;
+    this.maxCooldownMs = options?.maxCooldownMs ?? MAX_COOLDOWN_MS;
+    this.jitterMs = options?.jitterMs ?? DEFAULT_JITTER_MS;
+  }
+  /**
+   * Run `fn` under the origin's concurrency cap and behind any active
+   * cooldown. Put only the request in `fn`: the slot is released as soon as
+   * it settles, so body parsing doesn't hold one.
+   */
+  async run(input, fn) {
+    const state = this.stateFor(requestOrigin(input));
+    await this.acquire(state);
+    try {
+      for (; ; ) {
+        const remaining = state.blockedUntil - Date.now();
+        if (remaining <= 0) break;
+        await sleep(remaining + Math.random() * this.jitterMs);
+      }
+      return await fn();
+    } finally {
+      this.release(state);
+    }
+  }
+  /**
+   * {@link run} for a request whose response the gate should inspect: a `429`
+   * is recorded *before* the slot is released. Reporting after `run()` resolves
+   * is too late — `release()` hands the slot to the next queued waiter, which
+   * resumes, sees no cooldown, and sends into the limiter that just refused us.
+   *
+   * Prefer this over `run` for anything returning a `Response`.
+   */
+  runHttp(input, fn) {
+    return this.run(input, async () => {
+      const response = await fn();
+      if (response.status === 429) {
+        this.reportRateLimited(input, response.headers?.get("retry-after"));
+      }
+      return response;
+    });
+  }
+  /**
+   * Record an observed `429`, pausing every gated request to that origin.
+   * Monotonic: a shorter cooldown never shortens one already in effect.
+   */
+  reportRateLimited(input, retryAfterHeader) {
+    const cooldown = Math.min(
+      parseRetryAfterMs(retryAfterHeader) ?? this.defaultCooldownMs,
+      this.maxCooldownMs
+    );
+    const state = this.stateFor(requestOrigin(input));
+    state.blockedUntil = Math.max(state.blockedUntil, Date.now() + cooldown);
+  }
+  /** Milliseconds left on `input` origin's cooldown; `0` when not cooling down. */
+  cooldownRemainingMs(input) {
+    const state = this.states.get(requestOrigin(input));
+    if (!state) return 0;
+    return Math.max(0, state.blockedUntil - Date.now());
+  }
+  /**
+   * Drop all per-origin state, so test suites don't inherit each other's
+   * cooldowns. Waiters queued on the discarded state still drain normally.
+   */
+  reset() {
+    this.states.clear();
+  }
+  stateFor(origin) {
+    let state = this.states.get(origin);
+    if (!state) {
+      state = { blockedUntil: 0, active: 0, queue: [] };
+      this.states.set(origin, state);
+    }
+    return state;
+  }
+  acquire(state) {
+    if (state.active < this.maxConcurrent) {
+      state.active += 1;
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      state.queue.push(() => {
+        state.active += 1;
+        resolve();
+      });
+    });
+  }
+  release(state) {
+    state.active -= 1;
+    const next = state.queue.shift();
+    if (next) next();
+  }
+};
+var rateGate = new OriginRateGate();
+
 // src/providers/ark.ts
 var DigestMismatchError = class extends Error {
   constructor(message) {
@@ -604,7 +736,7 @@ var SettlementEventType = /* @__PURE__ */ ((SettlementEventType2) => {
   return SettlementEventType2;
 })(SettlementEventType || {});
 var RestArkProvider = class {
-  constructor(serverUrl = chunkL5ND2FJJ_cjs.DEFAULT_ARKADE_SERVER_URL) {
+  constructor(serverUrl = chunk7TXSPRN5_cjs.DEFAULT_ARKADE_SERVER_URL) {
     this.serverUrl = serverUrl;
   }
   serverUrl;
@@ -659,6 +791,9 @@ var RestArkProvider = class {
       throw toProviderUnavailable(err, "arkade");
     }
     if (response.ok) return response;
+    if (response.status === 429) {
+      rateGate.reportRateLimited(url, response.headers?.get("retry-after"));
+    }
     let body;
     try {
       body = await response.clone().text();
@@ -679,7 +814,7 @@ var RestArkProvider = class {
   }
   async getInfo() {
     const url = `${this.serverUrl}/v1/info`;
-    const response = await fetch(url);
+    const response = await rateGate.runHttp(url, () => fetch(url));
     if (!response.ok) {
       const errorText = await response.text();
       throwIfHttpUnavailable(response, "arkade", errorText);
@@ -2457,24 +2592,43 @@ var Packet = class _Packet {
     return packet;
   }
 };
+var INDEXER_MAX_ATTEMPTS = 3;
+var INDEXER_RETRY_BASE_MS = 250;
 async function indexerFetch(input, init) {
-  let res;
-  try {
-    res = await baseFetch(input, init);
-  } catch (err) {
-    throw toProviderUnavailable(err, "indexer");
-  }
-  if (!res.ok) {
+  const method = (init?.method ?? "GET").toUpperCase();
+  const maxAttempts = method === "GET" || method === "HEAD" ? INDEXER_MAX_ATTEMPTS : 1;
+  for (let attempt = 1; ; attempt++) {
+    const lastAttempt = attempt >= maxAttempts;
+    let res;
+    try {
+      res = await rateGate.runHttp(input, () => baseFetch(input, init));
+    } catch (err) {
+      const mapped = toProviderUnavailable(err, "indexer");
+      if (lastAttempt || !(mapped instanceof ProviderUnavailableError)) throw mapped;
+      await sleep2(retryDelayMs(attempt));
+      continue;
+    }
+    if (res.ok) return res;
     let body;
     try {
       body = await res.clone().text();
     } catch {
       body = void 0;
     }
-    throwIfHttpUnavailable(res, "indexer", body);
+    try {
+      throwIfHttpUnavailable(res, "indexer", body);
+    } catch (err) {
+      if (lastAttempt) throw err;
+      await sleep2(retryDelayMs(attempt));
+      continue;
+    }
+    return res;
   }
-  return res;
 }
+function retryDelayMs(attempt) {
+  return INDEXER_RETRY_BASE_MS * 2 ** (attempt - 1);
+}
+var sleep2 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 var IndexerTxType = /* @__PURE__ */ ((IndexerTxType2) => {
   IndexerTxType2[IndexerTxType2["INDEXER_TX_TYPE_UNSPECIFIED"] = 0] = "INDEXER_TX_TYPE_UNSPECIFIED";
   IndexerTxType2[IndexerTxType2["INDEXER_TX_TYPE_RECEIVED"] = 1] = "INDEXER_TX_TYPE_RECEIVED";
@@ -2490,7 +2644,7 @@ var ChainTxType = /* @__PURE__ */ ((ChainTxType2) => {
   return ChainTxType2;
 })(ChainTxType || {});
 var RestIndexerProvider = class {
-  constructor(serverUrl = chunkL5ND2FJJ_cjs.DEFAULT_ARKADE_SERVER_URL) {
+  constructor(serverUrl = chunk7TXSPRN5_cjs.DEFAULT_ARKADE_SERVER_URL) {
     this.serverUrl = serverUrl;
   }
   serverUrl;
@@ -2632,9 +2786,9 @@ var RestIndexerProvider = class {
                   yield {
                     txid: data.event.txid,
                     scripts: data.event.scripts || [],
-                    newVtxos: (data.event.newVtxos || []).map(convertVtxo),
-                    spentVtxos: (data.event.spentVtxos || []).map(convertVtxo),
-                    sweptVtxos: (data.event.sweptVtxos || []).map(convertVtxo),
+                    newVtxos: (data.event.newVtxos || []).map(chunk7TXSPRN5_cjs.convertVtxo),
+                    spentVtxos: (data.event.spentVtxos || []).map(chunk7TXSPRN5_cjs.convertVtxo),
+                    sweptVtxos: (data.event.sweptVtxos || []).map(chunk7TXSPRN5_cjs.convertVtxo),
                     tx: data.event.tx,
                     checkpointTxs: data.event.checkpointTxs
                   };
@@ -2780,7 +2934,7 @@ var RestIndexerProvider = class {
       throw new Error("Invalid vtxos data received");
     }
     return {
-      vtxos: data.vtxos.map(convertVtxo),
+      vtxos: data.vtxos.map(chunk7TXSPRN5_cjs.convertVtxo),
       page: data.page
     };
   }
@@ -2857,33 +3011,6 @@ function parseAssetMetadata(metadata) {
   }
   return out;
 }
-function convertVtxo(vtxo) {
-  return {
-    txid: vtxo.outpoint.txid,
-    vout: vtxo.outpoint.vout,
-    value: Number(vtxo.amount),
-    status: {
-      confirmed: !vtxo.isSwept && !vtxo.isPreconfirmed,
-      isLeaf: !vtxo.isPreconfirmed
-    },
-    virtualStatus: {
-      state: vtxo.isSpent ? "spent" : vtxo.isSwept ? "swept" : vtxo.isPreconfirmed ? "preconfirmed" : "settled",
-      commitmentTxIds: vtxo.commitmentTxids,
-      batchExpiry: vtxo.expiresAt ? Number(vtxo.expiresAt) * 1e3 : void 0
-    },
-    spentBy: vtxo.spentBy ?? "",
-    settledBy: vtxo.settledBy,
-    arkTxId: vtxo.arkTxid,
-    createdAt: new Date(Number(vtxo.createdAt) * 1e3),
-    isUnrolled: vtxo.isUnrolled,
-    isSpent: vtxo.isSpent,
-    script: vtxo.script,
-    assets: vtxo.assets?.map((a) => ({
-      assetId: a.assetId,
-      amount: BigInt(a.amount)
-    }))
-  };
-}
 var Response;
 ((Response2) => {
   function isBatchInfo(data) {
@@ -3015,7 +3142,8 @@ exports.isArkError = isArkError;
 exports.isEventSourceError = isEventSourceError;
 exports.isFetchTimeoutError = isFetchTimeoutError;
 exports.maybeArkError = maybeArkError;
+exports.rateGate = rateGate;
 exports.sdkVersion = sdkVersion;
 exports.setArkPsbtField = setArkPsbtField;
-//# sourceMappingURL=chunk-HHV5FPC6.cjs.map
-//# sourceMappingURL=chunk-HHV5FPC6.cjs.map
+//# sourceMappingURL=chunk-EB3ALGTM.cjs.map
+//# sourceMappingURL=chunk-EB3ALGTM.cjs.map