@trustware/sdk-staging 1.1.11-staging.1 → 1.1.11-staging.2

package/dist/wallet.cjs

@@ -264,7 +264,7 @@ var init_constants = __esm({
   "src/constants.ts"() {
     "use strict";
     SDK_NAME = "@trustware/sdk";
-    SDK_VERSION = "1.1.11-staging.1";
+    SDK_VERSION = "1.1.11-staging.2";
     API_ROOT = "https://bv-staging-api.trustware.io";
     API_PREFIX = "/api";
     WALLETCONNECT_PROJECT_ID = "72ea74c400f5111d43aea638d7d83a24";
@@ -287,16 +287,14 @@ var init_defaults = __esm({
 });
 
 // src/types/config.ts
-var DEFAULT_RETRY_CONFIG, DEFAULT_FEATURE_FLAGS;
+var DEFAULT_RETRY_CONFIG, RATE_LIMIT_WAIT_BUDGET_MS, DEFAULT_FEATURE_FLAGS;
 var init_config = __esm({
   "src/types/config.ts"() {
     "use strict";
     DEFAULT_RETRY_CONFIG = {
-      autoRetry: true,
-      maxRetries: 3,
-      baseDelayMs: 1e3,
       approachingThreshold: 5
     };
+    RATE_LIMIT_WAIT_BUDGET_MS = 1e4;
     DEFAULT_FEATURE_FLAGS = {
       tokensPagination: true,
       balanceStreaming: false,
@@ -3749,9 +3747,6 @@ function resolveConfig(input) {
   const theme = input.theme ?? "system";
   const messages = deepMerge(DEFAULT_MESSAGES, input.messages);
   const retry = {
-    autoRetry: input.retry?.autoRetry ?? DEFAULT_RETRY_CONFIG.autoRetry,
-    maxRetries: input.retry?.maxRetries ?? DEFAULT_RETRY_CONFIG.maxRetries,
-    baseDelayMs: input.retry?.baseDelayMs ?? DEFAULT_RETRY_CONFIG.baseDelayMs,
     approachingThreshold: input.retry?.approachingThreshold ?? DEFAULT_RETRY_CONFIG.approachingThreshold,
     onRateLimitInfo: input.retry?.onRateLimitInfo,
     onRateLimited: input.retry?.onRateLimited,
@@ -3852,50 +3847,54 @@ function notifyRateLimitCallbacks(info, isRateLimited, retryCount) {
     retry.onRateLimitApproaching(info, retry.approachingThreshold);
   }
 }
-function calculateBackoffDelay(baseDelayMs, retryCount, retryAfter) {
-  if (retryAfter && retryAfter > 0) {
-    return retryAfter * 1e3;
+function serverDirectedWaitMs(info) {
+  if (!info) return null;
+  if (typeof info.retryAfter === "number" && info.retryAfter > 0) {
+    return info.retryAfter * 1e3;
   }
-  return baseDelayMs * Math.pow(2, retryCount);
+  if (typeof info.reset === "number" && info.reset > 0) {
+    const untilReset = info.reset * 1e3 - Date.now();
+    if (untilReset > 0) return untilReset;
+  }
+  return null;
 }
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
-async function rateLimitedFetch(url, options = {}) {
-  const { skipRateLimit, ...fetchOptions } = options;
-  const cfg = TrustwareConfigStore.get();
-  if (!cfg.retry.autoRetry || skipRateLimit) {
-    return fetch(url, fetchOptions);
-  }
-  const { maxRetries, baseDelayMs } = cfg.retry;
+async function withRateLimitRetry(attempt) {
+  let waitedMs = 0;
   let retryCount = 0;
   while (true) {
-    const response = await fetch(url, fetchOptions);
+    const response = await attempt();
     const rateLimitInfo = parseRateLimitHeaders(response);
-    if (response.status === 429) {
+    if (response.status !== 429) {
       if (rateLimitInfo) {
-        notifyRateLimitCallbacks(rateLimitInfo, true, retryCount);
-      }
-      if (retryCount >= maxRetries) {
-        throw new RateLimitError(
-          rateLimitInfo || { limit: 0, remaining: 0, reset: 0 },
-          true
-        );
+        notifyRateLimitCallbacks(rateLimitInfo, false, 0);
       }
-      const delay = calculateBackoffDelay(
-        baseDelayMs,
-        retryCount,
-        rateLimitInfo?.retryAfter
-      );
-      await sleep(delay);
-      retryCount++;
-      continue;
+      return response;
     }
     if (rateLimitInfo) {
-      notifyRateLimitCallbacks(rateLimitInfo, false, 0);
+      notifyRateLimitCallbacks(rateLimitInfo, true, retryCount);
     }
-    return response;
+    const waitMs = serverDirectedWaitMs(rateLimitInfo);
+    const info = rateLimitInfo || { limit: 0, remaining: 0, reset: 0 };
+    if (waitMs === null) {
+      throw new RateLimitError(info, true);
+    }
+    if (waitedMs + waitMs > RATE_LIMIT_WAIT_BUDGET_MS) {
+      throw new RateLimitError(info, false);
+    }
+    await sleep(waitMs);
+    waitedMs += waitMs;
+    retryCount++;
+  }
+}
+async function rateLimitedFetch(url, options = {}) {
+  const { skipRateLimit, ...fetchOptions } = options;
+  if (skipRateLimit) {
+    return fetch(url, fetchOptions);
   }
+  return withRateLimitRetry(() => fetch(url, fetchOptions));
 }
 var RateLimitError;
 var init_http = __esm({
@@ -3903,9 +3902,11 @@ var init_http = __esm({
     "use strict";
     init_constants();
     init_config2();
+    init_config();
     RateLimitError = class extends Error {
       constructor(info, retriesExhausted) {
-        const message = retriesExhausted ? `Rate limit exceeded after max retries. Try again in ${info.retryAfter ?? Math.ceil((info.reset * 1e3 - Date.now()) / 1e3)} seconds.` : `Rate limit exceeded. Try again in ${info.retryAfter} seconds.`;
+        const seconds = info.retryAfter ?? (info.reset > 0 ? Math.max(0, Math.ceil((info.reset * 1e3 - Date.now()) / 1e3)) : null);
+        const message = seconds === null ? "Rate limit exceeded. The server did not say when to retry." : `Rate limit exceeded. Try again in ${seconds} seconds.`;
         super(message);
         this.name = "RateLimitError";
         this.rateLimitInfo = info;