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

package/README.md

@@ -37,8 +37,6 @@ The current widget flow is:
 
 `Home -> Select Token -> Confirm Deposit -> Processing -> Success/Error`
 
-The refactored widget keeps the same behavior, but the configuration surface is now documented around the actual `TrustwareConfigOptions` shape and the current widget step model.
-
 ## Installation
 
 Supports React `18.2+` and `19`.
@@ -115,7 +113,7 @@ type TrustwareConfigOptions = {
     };
   };
   autoDetectProvider?: boolean;
-  theme?: TrustwareWidgetTheme;
+  theme?: "light" | "dark" | "system"; // TrustwareTheme
   messages?: Partial<TrustwareWidgetMessages>;
   retry?: RetryConfig;
   walletConnect?: WalletConnectConfig;
@@ -172,7 +170,8 @@ type TrustwareConfigOptions = {
 ### Other Config Groups
 
 - `autoDetectProvider`: enables Trustware-managed wallet discovery.
-- `theme`: widget color and radius customization.
+- `theme`: widget color mode — `"light" | "dark" | "system"` (default
+  `"system"`). Switch it at runtime with `Trustware.setTheme("dark")`.
 - `messages`: top-level copy overrides.
 - `retry`: API retry and rate-limit behavior.
 - `walletConnect`: WalletConnect overrides.
@@ -232,6 +231,13 @@ export function DepositPanel() {
 }
 ```
 
+`useWagmi` (like `useEIP1193`) is a plain adapter factory, not a React hook,
+despite the `use` prefix. If your ESLint setup runs `react-hooks/rules-of-hooks`
+it will flag the call inside the `useMemo` callback above; silence it with an
+`eslint-disable-next-line react-hooks/rules-of-hooks` comment — the call is
+safe. See [docs.trustware.io](https://docs.trustware.io/guides/embedded-wallets#adapt-the-embedded-wallet)
+for the same pattern with embedded wallets.
+
 Use this mode when:
 
 - your app already owns wallet state
@@ -285,19 +291,28 @@ Use this when you want Trustware’s routing and wallet plumbing without the wid
 ```ts
 import { Trustware } from "@trustware/sdk";
 
+// buildRoute states both sides explicitly. fromAmount is in the source token's
+// smallest unit, and the estimate comes back on the route — there is no
+// separate quote call.
 const route = await Trustware.buildRoute({
-  amount: "0.1",
+  fromChain: "1",
+  fromToken: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC on Ethereum
+  toChain: "8453",
+  toToken: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE", // native on Base
+  fromAmount: "25000000", // 25 USDC (6 decimals)
   fromAddress: await Trustware.getAddress(),
+  toAddress: "0xDestination...",
 });
+console.log(route.route?.estimate, route.finalExchangeRate);
 
-const quote = await Trustware.getQuote(route);
-
-const result = await Trustware.runTopUp({
-  amount: "0.1",
-  fromAddress: await Trustware.getAddress(),
-});
+// Or let the SDK own route + submit + receipt + polling. Missing route fields
+// come from the provider config; the sender comes from the attached wallet.
+const tx = await Trustware.runTopUp({ fromAmount: "25000000" });
+console.log(tx.status, tx.destTxHash);
 ```
 
+See [docs.trustware.io](https://docs.trustware.io) for the full headless flow.
+
 ## Common Config Examples
 
 ### Fixed Amount Deposit
@@ -347,26 +362,44 @@ Trustware.setDestinationAddress("0xDestination...");
 
 ## Rate Limiting
 
-Client retry behavior is configured through `retry`.
+The API is rate limited per API key, and that limit is shared by everyone using
+your key — not per end user. Your key's limit, its remaining requests and the
+window boundary come back on every response (`X-RateLimit-Limit`, `-Remaining`,
+`-Reset`, plus `Retry-After` on a 429).
+
+The SDK retries 429s on the schedule those headers state — it keeps no schedule
+of its own to disagree with them. It waits exactly as long as the server asks,
+for as long as the total stays under 10 seconds. Past that it stops and throws,
+because how long your app can afford to block is the one thing the server can't
+know. If a response carries no timing at all, the SDK stops rather than
+guessing: the limit is a fixed window, so an invented delay either lands inside
+the same closed window or overshoots one it could have read exactly.
+
+None of that is configurable — the limit is enforced server-side, so no client
+setting can widen it. If you need more headroom, ask us to raise the limit on
+your key. `retry` configures observability only:
 
 ```ts
 const config = {
   ...trustwareConfig,
   retry: {
-    autoRetry: true,
-    maxRetries: 3,
-    baseDelayMs: 1000,
+    onRateLimitInfo: (info) => console.debug(info.remaining, "requests left"),
+    onRateLimited: (info, attempt) => console.warn("429", attempt, info),
+    onRateLimitApproaching: (info) => showSoftWarning(info),
     approachingThreshold: 5,
   },
 } satisfies TrustwareConfigOptions;
 ```
 
-If retries are exhausted, the SDK throws `RateLimitError`.
+`RateLimitError` distinguishes the two ways the SDK gives up:
+
+- `retriesExhausted: false` — the wait is known and simply longer than the SDK
+  will block for. `rateLimitInfo.retryAfter` holds it, so show the user when to
+  come back instead of leaving them on a spinner.
+- `retriesExhausted: true` — the response carried no usable timing, so there was
+  nothing to retry against.
 
 ## Docs
 
-- [Integration Guide](docs/intergrationGuide.md)
-- [Core Guide](docs/coreGuide.md)
-- [Backend RPC Offload PDR](docs/backend-rpc-offload-pdr.md)
-- [Widget Architecture Boundaries](docs/widget-architecture-boundaries.md)
-- [Widget Refactor Baseline](docs/widget-refactor-baseline.md)
+Full API reference, integration guides, and examples live at
+[docs.trustware.io](https://docs.trustware.io).

package/dist/{blockchain-BxAFzp0s.d.cts → blockchain-DmCPxnxr.d.cts}

@@ -47,10 +47,34 @@ type TokenPageResult = {
     data: TokenDef[];
     pageInfo: TokenPageInfo;
 };
+/**
+ * Terminal state of an address balance scan.
+ *
+ * `partial` is the one field a caller cannot reconstruct from the chunks: the
+ * backend scans every configured chain and reports `partial: true` when any of
+ * them failed, so "no balance on chain X" and "we could not reach chain X" look
+ * identical in the rows themselves. Rendering an empty wallet off a partial
+ * scan is the failure this exists to prevent.
+ */
+type BalanceStreamSummary = {
+    address: string;
+    partial: boolean;
+    /** Chains that reported a result — equal to `total` on a complete scan. */
+    completed: number;
+    total: number;
+    /** Server-side scan duration. Absent on the buffered path, which does not report it. */
+    elapsedMs?: number;
+};
 type BalanceStreamOptions = {
     stream?: boolean;
     signal?: AbortSignal;
     strict?: boolean;
+    /**
+     * Called once per scan with its terminal state, on the streamed and buffered
+     * paths alike — including when a stream fails and falls back — so a consumer
+     * can trust `partial` without knowing which path served it.
+     */
+    onSummary?: (summary: BalanceStreamSummary) => void;
 };
 type GetBalancesOptions = {
     /** Bypass the in-memory balance cache and re-fetch fresh data from the network. */
@@ -111,4 +135,4 @@ type TokenWithBalance = TokenDef & {
     balance?: bigint;
 };
 
-export type { BalanceRow as B, ChainDef as C, GetBalancesOptions as G, NativeCurrency as N, TokenDef as T, WalletAddressBalanceWrapper as W, BalanceStreamOptions as a, ChainMeta as b, ChainType as c, TokenMeta as d, TokenPageInfo as e, TokenPageOptions as f, TokenPageResult as g, TokenType as h, TokenWithBalance as i };
+export type { BalanceRow as B, ChainDef as C, GetBalancesOptions as G, NativeCurrency as N, TokenDef as T, WalletAddressBalanceWrapper as W, BalanceStreamOptions as a, BalanceStreamSummary as b, ChainMeta as c, ChainType as d, TokenMeta as e, TokenPageInfo as f, TokenPageOptions as g, TokenPageResult as h, TokenType as i, TokenWithBalance as j };

package/dist/{blockchain-BxAFzp0s.d.ts → blockchain-DmCPxnxr.d.ts}

@@ -47,10 +47,34 @@ type TokenPageResult = {
     data: TokenDef[];
     pageInfo: TokenPageInfo;
 };
+/**
+ * Terminal state of an address balance scan.
+ *
+ * `partial` is the one field a caller cannot reconstruct from the chunks: the
+ * backend scans every configured chain and reports `partial: true` when any of
+ * them failed, so "no balance on chain X" and "we could not reach chain X" look
+ * identical in the rows themselves. Rendering an empty wallet off a partial
+ * scan is the failure this exists to prevent.
+ */
+type BalanceStreamSummary = {
+    address: string;
+    partial: boolean;
+    /** Chains that reported a result — equal to `total` on a complete scan. */
+    completed: number;
+    total: number;
+    /** Server-side scan duration. Absent on the buffered path, which does not report it. */
+    elapsedMs?: number;
+};
 type BalanceStreamOptions = {
     stream?: boolean;
     signal?: AbortSignal;
     strict?: boolean;
+    /**
+     * Called once per scan with its terminal state, on the streamed and buffered
+     * paths alike — including when a stream fails and falls back — so a consumer
+     * can trust `partial` without knowing which path served it.
+     */
+    onSummary?: (summary: BalanceStreamSummary) => void;
 };
 type GetBalancesOptions = {
     /** Bypass the in-memory balance cache and re-fetch fresh data from the network. */
@@ -111,4 +135,4 @@ type TokenWithBalance = TokenDef & {
     balance?: bigint;
 };
 
-export type { BalanceRow as B, ChainDef as C, GetBalancesOptions as G, NativeCurrency as N, TokenDef as T, WalletAddressBalanceWrapper as W, BalanceStreamOptions as a, ChainMeta as b, ChainType as c, TokenMeta as d, TokenPageInfo as e, TokenPageOptions as f, TokenPageResult as g, TokenType as h, TokenWithBalance as i };
+export type { BalanceRow as B, ChainDef as C, GetBalancesOptions as G, NativeCurrency as N, TokenDef as T, WalletAddressBalanceWrapper as W, BalanceStreamOptions as a, BalanceStreamSummary as b, ChainMeta as c, ChainType as d, TokenMeta as e, TokenPageInfo as f, TokenPageOptions as g, TokenPageResult as h, TokenType as i, TokenWithBalance as j };

package/dist/constants.cjs

@@ -30,7 +30,7 @@ __export(constants_exports, {
 });
 module.exports = __toCommonJS(constants_exports);
 var SDK_NAME = "@trustware/sdk";
-var SDK_VERSION = "1.1.11-staging.1";
+var SDK_VERSION = "1.1.12-staging.1";
 var API_ROOT = "https://bv-staging-api.trustware.io";
 var GTM_ID = "GTM-TZDGNCXB";
 var API_PREFIX = "/api";

package/dist/constants.mjs

@@ -1,6 +1,6 @@
 // src/constants.ts
 var SDK_NAME = "@trustware/sdk";
-var SDK_VERSION = "1.1.11-staging.1";
+var SDK_VERSION = "1.1.12-staging.1";
 var API_ROOT = "https://bv-staging-api.trustware.io";
 var GTM_ID = "GTM-TZDGNCXB";
 var API_PREFIX = "/api";

package/dist/{core-BgYLe9Q7.d.ts → core-B4YDGtJT.d.ts}

@@ -1,6 +1,6 @@
-import { n as BuildRouteResult, k as Transaction, T as TrustwareConfigOptions, i as WalletInterFaceAPI, z as ResolvedTrustwareConfig, V as TrustwareTheme, a1 as WalletIdentity, w as walletManager, Y as WalletAddressResolution, a8 as buildRoute, a9 as buildDepositAddress, aa as submitReceipt, ab as submitStepReceipt, ac as getStatus, ad as pollStatus } from './manager-BY3NHAks.js';
-import { C as ChainDef, c as ChainType, G as GetBalancesOptions, B as BalanceRow, a as BalanceStreamOptions, W as WalletAddressBalanceWrapper } from './blockchain-BxAFzp0s.js';
-import { T as Token } from './types-BJY9r-mz.js';
+import { n as BuildRouteResult, k as Transaction, T as TrustwareConfigOptions, i as WalletInterFaceAPI, A as ResolvedTrustwareConfig, X as TrustwareTheme, a2 as WalletIdentity, w as walletManager, Z as WalletAddressResolution, aa as buildRoute, ab as buildDepositAddress, ac as submitReceipt, ad as submitStepReceipt, ae as getStatus, af as pollStatus } from './manager-D8nQsod2.js';
+import { C as ChainDef, d as ChainType, G as GetBalancesOptions, B as BalanceRow, a as BalanceStreamOptions, W as WalletAddressBalanceWrapper } from './blockchain-DmCPxnxr.js';
+import { T as Token } from './types-CMmx0S4U.js';
 
 type AddressValidationResult = {
     isValid: boolean;

package/dist/{core-fLSt4qD2.d.cts → core-Ck7dinYj.d.cts}

@@ -1,6 +1,6 @@
-import { n as BuildRouteResult, k as Transaction, T as TrustwareConfigOptions, i as WalletInterFaceAPI, z as ResolvedTrustwareConfig, V as TrustwareTheme, a1 as WalletIdentity, w as walletManager, Y as WalletAddressResolution, a8 as buildRoute, a9 as buildDepositAddress, aa as submitReceipt, ab as submitStepReceipt, ac as getStatus, ad as pollStatus } from './manager-DT8enQbE.cjs';
-import { C as ChainDef, c as ChainType, G as GetBalancesOptions, B as BalanceRow, a as BalanceStreamOptions, W as WalletAddressBalanceWrapper } from './blockchain-BxAFzp0s.cjs';
-import { T as Token } from './types-DX3HtFcn.cjs';
+import { n as BuildRouteResult, k as Transaction, T as TrustwareConfigOptions, i as WalletInterFaceAPI, A as ResolvedTrustwareConfig, X as TrustwareTheme, a2 as WalletIdentity, w as walletManager, Z as WalletAddressResolution, aa as buildRoute, ab as buildDepositAddress, ac as submitReceipt, ad as submitStepReceipt, ae as getStatus, af as pollStatus } from './manager-BZ8gyHGT.cjs';
+import { C as ChainDef, d as ChainType, G as GetBalancesOptions, B as BalanceRow, a as BalanceStreamOptions, W as WalletAddressBalanceWrapper } from './blockchain-DmCPxnxr.cjs';
+import { T as Token } from './types-DEUb5IZA.cjs';
 
 type AddressValidationResult = {
     isValid: boolean;

package/dist/core.cjs

@@ -47,19 +47,27 @@ 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,
+      // On by default: an address scan covers every configured chain and takes
+      // seconds end to end, so streaming turns one long wait into a wallet that
+      // fills in as results land — first chunk in ~200ms against a ~2.3s buffered
+      // response, measured on a live backend.
+      //
+      // Safe to default because the path degrades on its own: a backend with
+      // BALANCE_STREAM_ENABLED off refuses the stream, and the SDK falls back to
+      // the buffered endpoint (emitting balance_stream_fallback), as does any
+      // runtime whose fetch has no readable body — React Native, most notably.
+      // The cost of defaulting ahead of a backend is one refused request per scan.
+      balanceStreaming: true,
       shouldAllowGA4: true,
       swapMode: false,
       swapDefaultDestToken: null,
@@ -75,7 +83,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.12-staging.1";
     API_ROOT = "https://bv-staging-api.trustware.io";
     API_PREFIX = "/api";
     WALLETCONNECT_PROJECT_ID = "72ea74c400f5111d43aea638d7d83a24";
@@ -118,7 +126,7 @@ async function assertOK(r) {
   throw new Error(`HTTP ${r.status}: ${msg}`);
 }
 async function validateSdkAccess() {
-  const r = await fetch(`${apiBase()}/sdk/validate`, {
+  const r = await fetch(`${apiBase()}/v1/sdk/validate`, {
     method: "GET",
     headers: jsonHeaders()
   });
@@ -157,50 +165,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);
+    }
+    const waitMs = serverDirectedWaitMs(rateLimitInfo);
+    const info = rateLimitInfo || { limit: 0, remaining: 0, reset: 0 };
+    if (waitMs === null) {
+      throw new RateLimitError(info, true);
     }
-    return response;
+    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({
@@ -208,9 +220,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;
@@ -1795,6 +1809,16 @@ function mergeBalanceWrappers(current, incoming) {
   }
   return Array.from(merged.values());
 }
+function toSummary(frame, address) {
+  const total = toNumberOrUndefined(frame.total) ?? 0;
+  return {
+    address: toStringOrUndefined(frame.address) ?? address,
+    partial: Boolean(frame.partial),
+    completed: toNumberOrUndefined(frame.completed) ?? 0,
+    total,
+    elapsedMs: toNumberOrUndefined(frame.elapsed)
+  };
+}
 async function parseStreamingBalances(response, address, options = {}) {
   if (!response.body) {
     throw new Error("balances stream: empty response body");
@@ -1815,7 +1839,12 @@ async function parseStreamingBalances(response, address, options = {}) {
           if (!trimmed) continue;
           try {
             const parsed = JSON.parse(trimmed);
-            if (!parsed.chain_id) continue;
+            if (!parsed.chain_id) {
+              if (parsed.type === "summary") {
+                options.onSummary?.(toSummary(parsed, address));
+              }
+              continue;
+            }
             const chunk = normalizeStreamChunk(parsed);
             emitBalanceStreamChunk(address, chunk.length);
             yield chunk;
@@ -1834,6 +1863,8 @@ async function parseStreamingBalances(response, address, options = {}) {
             const chunk = normalizeStreamChunk(parsed);
             emitBalanceStreamChunk(address, chunk.length);
             yield chunk;
+          } else if (parsed.type === "summary") {
+            options.onSummary?.(toSummary(parsed, address));
           }
         } catch (error) {
           if (options.strict) {
@@ -1867,7 +1898,7 @@ async function getBalances(chainRef, address, opts) {
     if (cached) return cached;
   }
   const url = `${apiBase()}/v1/data/wallets/${encodeURIComponent(chainKey)}/${trimmedAddress}/balances`;
-  const response = await fetch(url, {
+  const response = await rateLimitedFetch(url, {
     method: "GET",
     credentials: "omit",
     headers: jsonHeaders()
@@ -1888,7 +1919,7 @@ async function getBalancesByAddress(address, opts) {
     }
     return merged;
   }
-  const url = `${apiBase()}/data/balances/${address}`;
+  const url = `${apiBase()}/v1/data/balances/${address}`;
   const r = await rateLimitedFetch(url, {
     method: "GET",
     credentials: "omit",
@@ -1896,14 +1927,27 @@ async function getBalancesByAddress(address, opts) {
   });
   if (!r.ok) throw new Error(`balances: HTTP ${r.status}`);
   const j = await r.json();
-  return Array.isArray(j) ? j : j.results ?? [];
+  const results = Array.isArray(j) ? j : j.results ?? [];
+  if (opts?.onSummary) {
+    const completed = results.length;
+    opts.onSummary({
+      address,
+      partial: Array.isArray(j) ? false : Boolean(j.partial),
+      completed,
+      total: completed
+    });
+  }
+  return results;
+}
+function bufferedOptions(opts) {
+  return { ...opts, stream: false };
 }
 async function* getBalancesByAddressStream(address, opts = {}) {
   if (!TrustwareConfigStore.get().features.balanceStreaming) {
-    yield await getBalancesByAddress(address);
+    yield await getBalancesByAddress(address, bufferedOptions(opts));
     return;
   }
-  const url = `${apiBase()}/data/balances/${address}?stream=1`;
+  const url = `${apiBase()}/v1/data/balances/${address}?stream=1`;
   try {
     const response = await rateLimitedFetch(url, {
       method: "GET",
@@ -1919,7 +1963,14 @@ async function* getBalancesByAddressStream(address, opts = {}) {
     const contentType = response.headers.get("content-type") ?? "";
     if (contentType.includes("application/json")) {
       const payload = await response.json();
-      yield Array.isArray(payload) ? payload : payload.results ?? [];
+      const results = Array.isArray(payload) ? payload : payload.results ?? [];
+      opts.onSummary?.({
+        address,
+        partial: Array.isArray(payload) ? false : Boolean(payload.partial),
+        completed: results.length,
+        total: results.length
+      });
+      yield results;
       return;
     }
     const stream = await parseStreamingBalances(response, address, opts);
@@ -1928,7 +1979,7 @@ async function* getBalancesByAddressStream(address, opts = {}) {
     }
   } catch (error) {
     emitBalanceStreamFallback(address, error);
-    yield await getBalancesByAddress(address);
+    yield await getBalancesByAddress(address, bufferedOptions(opts));
   }
 }
 async function ensureRegistry() {
@@ -4115,7 +4166,18 @@ async function getStatus(intentId) {
   );
   await assertOK(r);
   const j = await r.json();
-  return j.data;
+  return normalizeStatusPayload(j.data);
+}
+function normalizeStatusPayload(raw) {
+  if (!raw || typeof raw !== "object") return raw;
+  const wire = raw;
+  const out = { ...wire };
+  for (const [snake, camel] of Object.entries(STATUS_WIRE_TO_CAMEL)) {
+    if (out[camel] !== void 0) continue;
+    if (!(snake in wire)) continue;
+    out[camel] = wire[snake];
+  }
+  return out;
 }
 async function pollStatus(intentId, { intervalMs = 2e3, timeoutMs = 5 * 6e4 } = {}) {
   const t0 = Date.now();
@@ -4126,12 +4188,39 @@ async function pollStatus(intentId, { intervalMs = 2e3, timeoutMs = 5 * 6e4 } =
     await new Promise((r) => setTimeout(r, intervalMs));
   }
 }
+var STATUS_WIRE_TO_CAMEL;
 var init_routes = __esm({
   "src/core/routes.ts"() {
     "use strict";
     init_http();
     init_store();
     init_address();
+    STATUS_WIRE_TO_CAMEL = {
+      intent_id: "intentId",
+      from_address: "fromAddress",
+      to_address: "toAddress",
+      from_chain_id: "fromChainId",
+      to_chain_id: "toChainId",
+      source_tx_hash: "sourceTxHash",
+      dest_tx_hash: "destTxHash",
+      request_id: "requestId",
+      provider_request_id: "providerRequestId",
+      transaction_request: "transactionRequest",
+      status_raw: "statusRaw",
+      route_path: "routePath",
+      route_status: "routeStatus",
+      to_amount_wei: "toAmountWei",
+      from_chain_block: "fromChainBlock",
+      to_chain_block: "toChainBlock",
+      from_chain_tx_url: "fromChainTxUrl",
+      to_chain_tx_url: "toChainTxUrl",
+      gas_status: "gasStatus",
+      is_gmp_transaction: "isGMPTransaction",
+      axelar_transaction_url: "axelarTransactionUrl",
+      create_date: "createdDate",
+      update_date: "updatedDate",
+      time_spent_ms: "timeSpentMs"
+    };
   }
 });
 
@@ -6604,9 +6693,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,
@@ -6739,6 +6825,7 @@ var init_core = __esm({
     init_store();
     init_wallets();
     init_routes();
+    init_routes();
     init_balances();
     init_tx();
     init_http();
@@ -6893,7 +6980,8 @@ var init_core = __esm({
 // src/core.ts
 var core_exports = {};
 __export(core_exports, {
-  Trustware: () => Trustware
+  Trustware: () => Trustware,
+  assertValidPostHook: () => assertValidPostHook
 });
 module.exports = __toCommonJS(core_exports);
 var init_core2 = __esm({
@@ -6904,6 +6992,7 @@ var init_core2 = __esm({
 init_core2();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  Trustware
+  Trustware,
+  assertValidPostHook
 });
 //# sourceMappingURL=core.cjs.map