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

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/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.11-staging.2";
 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.11-staging.2";
 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-B1WCJfDI.d.ts}

@@ -1,4 +1,4 @@
-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 { 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-Bw8b1wSD.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';
 

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

@@ -1,4 +1,4 @@
-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 { 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-DNGk1YkR.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';
 

package/dist/core.cjs

@@ -47,16 +47,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,
@@ -75,7 +73,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";
@@ -157,60 +155,66 @@ 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);
+        notifyRateLimitCallbacks(rateLimitInfo, false, 0);
       }
-      if (retryCount >= maxRetries) {
-        throw new RateLimitError(
-          rateLimitInfo || { limit: 0, remaining: 0, reset: 0 },
-          true
-        );
-      }
-      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);
+    }
+    if (waitedMs + waitMs > RATE_LIMIT_WAIT_BUDGET_MS) {
+      throw new RateLimitError(info, false);
     }
-    return response;
+    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({
   "src/core/http.ts"() {
     "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;
@@ -1867,7 +1871,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()
@@ -4115,7 +4119,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 +4141,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 +6646,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 +6778,7 @@ var init_core = __esm({
     init_store();
     init_wallets();
     init_routes();
+    init_routes();
     init_balances();
     init_tx();
     init_http();
@@ -6893,7 +6933,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 +6945,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