@getpara/core-sdk 3.0.0-alpha.1 → 3.0.0

package/dist/esm/shares/enclave.js

@@ -1,6 +1,7 @@
 import {
   __async
 } from "../chunk-7B52C2XE.js";
+import { wrapWithSpan } from "../telemetry/tracer.js";
 class EnclaveClient {
   constructor({
     userManagementClient,
@@ -172,40 +173,59 @@ ${exportedAsBase64}
    * Persist key shares to the enclave
    * @param shares Array of share data to persist
    */
+  // enclave.persist_shares wraps the encrypt + POST /enclave/key-shares pair so
+  // both the (CPU-bound) ECIES encryption and the network call show up under a
+  // named parent in the trace. Encryption can dominate the wall time so it's
+  // worth spelling out separately from the POST itself.
   persistShares(shares) {
     return __async(this, null, function* () {
-      const payload = {
-        shares,
-        jwt: this.retrieveJwt()
-      };
-      const encryptedPayload = yield this.encryptForEnclave(JSON.stringify(payload));
-      const encryptedPayloadStr = JSON.stringify(encryptedPayload);
-      return yield this.userManagementClient.persistEnclaveShares({ encryptedPayload: encryptedPayloadStr });
+      return wrapWithSpan(
+        "enclave.persist_shares",
+        () => __async(this, null, function* () {
+          const payload = {
+            shares,
+            jwt: this.retrieveJwt()
+          };
+          const encryptedPayload = yield this.encryptForEnclave(JSON.stringify(payload));
+          const encryptedPayloadStr = JSON.stringify(encryptedPayload);
+          return yield this.userManagementClient.persistEnclaveShares({ encryptedPayload: encryptedPayloadStr });
+        }),
+        { "enclave.share_count": shares.length }
+      );
     });
   }
   /**
    * Retrieve key shares from the enclave
    * @param query Query parameters for finding shares (single query or array of queries)
    */
+  // enclave.retrieve_shares wraps the JWT issue + ECDH keypair gen + GET
+  // /enclave/key-shares + decrypt pipeline. The decrypt step can be slow on
+  // many-share accounts so a named span makes that latency easy to spot.
   retrieveShares(query) {
     return __async(this, null, function* () {
-      yield this.issueEnclaveJwt();
-      const frontendKeyPair = yield this.generateFrontendKeyPair();
-      const responsePublicKeyPEM = yield this.exportPublicKeyToPEM(frontendKeyPair.publicKey);
-      const fullQuery = query.map((q) => ({
-        userId: q.userId
-      }));
-      const payload = {
-        query: fullQuery,
-        responsePublicKey: responsePublicKeyPEM,
-        jwt: this.retrieveJwt()
-      };
-      const encryptedPayload = yield this.encryptForEnclave(JSON.stringify(payload));
-      const encryptedPayloadStr = JSON.stringify(encryptedPayload);
-      const response = yield this.userManagementClient.retrieveEnclaveShares(encryptedPayloadStr);
-      const encryptedResponse = JSON.parse(response.payload);
-      const decryptedData = yield this.decryptForFrontend(encryptedResponse);
-      return Array.isArray(decryptedData == null ? void 0 : decryptedData.shares) ? decryptedData.shares : [];
+      return wrapWithSpan(
+        "enclave.retrieve_shares",
+        () => __async(this, null, function* () {
+          yield this.issueEnclaveJwt();
+          const frontendKeyPair = yield this.generateFrontendKeyPair();
+          const responsePublicKeyPEM = yield this.exportPublicKeyToPEM(frontendKeyPair.publicKey);
+          const fullQuery = query.map((q) => ({
+            userId: q.userId
+          }));
+          const payload = {
+            query: fullQuery,
+            responsePublicKey: responsePublicKeyPEM,
+            jwt: this.retrieveJwt()
+          };
+          const encryptedPayload = yield this.encryptForEnclave(JSON.stringify(payload));
+          const encryptedPayloadStr = JSON.stringify(encryptedPayload);
+          const response = yield this.userManagementClient.retrieveEnclaveShares(encryptedPayloadStr);
+          const encryptedResponse = JSON.parse(response.payload);
+          const decryptedData = yield this.decryptForFrontend(encryptedResponse);
+          return Array.isArray(decryptedData == null ? void 0 : decryptedData.shares) ? decryptedData.shares : [];
+        }),
+        { "enclave.query_count": query.length }
+      );
     });
   }
   deleteShares() {

package/dist/esm/state/CoreStateManager.js

@@ -80,7 +80,7 @@ const _CoreStateManager = class _CoreStateManager {
    * Extracts all data needed by UI consumers from authStateResult.
    */
   computeAuthStateInfo(authContext, walletContext) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _A, _B, _C, _D, _E, _F, _G, _H, _I;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _A, _B, _C, _D, _E, _F, _G, _H, _I, _J, _K, _L;
     const defaultAuthStateInfo = {
       userId: null,
       isPasskeySupported: false,
@@ -98,6 +98,9 @@ const _CoreStateManager = class _CoreStateManager {
       passkeyId: null,
       verificationUrl: null,
       verificationFullUrl: null,
+      deliveryChannel: null,
+      fallbackUsed: false,
+      fallbackChannel: null,
       externalWalletVerification: null,
       recoverySecret: null,
       isNewUser: false
@@ -137,6 +140,9 @@ const _CoreStateManager = class _CoreStateManager {
     let verificationFullUrl = null;
     let passkeyHints = null;
     let passkeyId = null;
+    let deliveryChannel = null;
+    let fallbackUsed = false;
+    let fallbackChannel = null;
     if (stage === "login") {
       const loginState = authStateResult;
       const authMethods = (_j = loginState.loginAuthMethods) != null ? _j : [];
@@ -170,6 +176,9 @@ const _CoreStateManager = class _CoreStateManager {
       const verifyState = authStateResult;
       verificationUrl = (_C = verifyState.loginUrl) != null ? _C : null;
       verificationFullUrl = (_D = verifyState.loginFullUrl) != null ? _D : null;
+      deliveryChannel = (_E = verifyState.deliveryChannel) != null ? _E : null;
+      fallbackUsed = (_F = verifyState.fallbackUsed) != null ? _F : false;
+      fallbackChannel = (_G = verifyState.fallbackChannel) != null ? _G : null;
     }
     return {
       userId,
@@ -188,10 +197,13 @@ const _CoreStateManager = class _CoreStateManager {
       passkeyId,
       verificationUrl,
       verificationFullUrl,
+      deliveryChannel,
+      fallbackUsed,
+      fallbackChannel,
       externalWalletVerification: externalWalletVerification ? {
-        signatureVerificationMessage: (_E = externalWalletVerification.signatureVerificationMessage) != null ? _E : "",
-        walletAddress: (_G = (_F = externalWalletVerification.externalWallet) == null ? void 0 : _F.address) != null ? _G : "",
-        walletType: (_I = (_H = externalWalletVerification.externalWallet) == null ? void 0 : _H.type) != null ? _I : ""
+        signatureVerificationMessage: (_H = externalWalletVerification.signatureVerificationMessage) != null ? _H : "",
+        walletAddress: (_J = (_I = externalWalletVerification.externalWallet) == null ? void 0 : _I.address) != null ? _J : "",
+        walletType: (_L = (_K = externalWalletVerification.externalWallet) == null ? void 0 : _K.type) != null ? _L : ""
       } : null,
       recoverySecret,
       isNewUser
@@ -253,7 +265,7 @@ const _CoreStateManager = class _CoreStateManager {
   }
   authStateInfoEqual(a, b) {
     var _a, _b, _c, _d, _e, _f, _g, _h, _i;
-    return a.userId === b.userId && a.isPasskeySupported === b.isPasskeySupported && a.hasPasskey === b.hasPasskey && a.hasPassword === b.hasPassword && a.hasPin === b.hasPin && a.passkeyUrl === b.passkeyUrl && a.passkeyFullUrl === b.passkeyFullUrl && a.passkeyKnownDeviceUrl === b.passkeyKnownDeviceUrl && a.passwordUrl === b.passwordUrl && a.passwordFullUrl === b.passwordFullUrl && a.pinUrl === b.pinUrl && a.pinFullUrl === b.pinFullUrl && a.passkeyId === b.passkeyId && a.verificationUrl === b.verificationUrl && a.verificationFullUrl === b.verificationFullUrl && a.recoverySecret === b.recoverySecret && a.isNewUser === b.isNewUser && ((_a = a.externalWalletVerification) == null ? void 0 : _a.signatureVerificationMessage) === ((_b = b.externalWalletVerification) == null ? void 0 : _b.signatureVerificationMessage) && ((_c = a.externalWalletVerification) == null ? void 0 : _c.walletAddress) === ((_d = b.externalWalletVerification) == null ? void 0 : _d.walletAddress) && ((_e = a.externalWalletVerification) == null ? void 0 : _e.walletType) === ((_f = b.externalWalletVerification) == null ? void 0 : _f.walletType) && ((_g = a.passkeyHints) == null ? void 0 : _g.length) === ((_h = b.passkeyHints) == null ? void 0 : _h.length) && ((_i = a.passkeyHints) != null ? _i : []).every(
+    return a.userId === b.userId && a.isPasskeySupported === b.isPasskeySupported && a.hasPasskey === b.hasPasskey && a.hasPassword === b.hasPassword && a.hasPin === b.hasPin && a.passkeyUrl === b.passkeyUrl && a.passkeyFullUrl === b.passkeyFullUrl && a.passkeyKnownDeviceUrl === b.passkeyKnownDeviceUrl && a.passwordUrl === b.passwordUrl && a.passwordFullUrl === b.passwordFullUrl && a.pinUrl === b.pinUrl && a.pinFullUrl === b.pinFullUrl && a.passkeyId === b.passkeyId && a.verificationUrl === b.verificationUrl && a.verificationFullUrl === b.verificationFullUrl && a.deliveryChannel === b.deliveryChannel && a.fallbackUsed === b.fallbackUsed && a.fallbackChannel === b.fallbackChannel && a.recoverySecret === b.recoverySecret && a.isNewUser === b.isNewUser && ((_a = a.externalWalletVerification) == null ? void 0 : _a.signatureVerificationMessage) === ((_b = b.externalWalletVerification) == null ? void 0 : _b.signatureVerificationMessage) && ((_c = a.externalWalletVerification) == null ? void 0 : _c.walletAddress) === ((_d = b.externalWalletVerification) == null ? void 0 : _d.walletAddress) && ((_e = a.externalWalletVerification) == null ? void 0 : _e.walletType) === ((_f = b.externalWalletVerification) == null ? void 0 : _f.walletType) && ((_g = a.passkeyHints) == null ? void 0 : _g.length) === ((_h = b.passkeyHints) == null ? void 0 : _h.length) && ((_i = a.passkeyHints) != null ? _i : []).every(
       (hint, i) => hint.useragent === b.passkeyHints[i].useragent && hint.aaguid === b.passkeyHints[i].aaguid
     );
   }

package/dist/esm/state/actors/setupPara.js

@@ -3,7 +3,10 @@ import {
 } from "../../chunk-7B52C2XE.js";
 import { fromPromise } from "xstate";
 const createSetupParaActor = (paraCoreInterface) => fromPromise(() => __async(void 0, null, function* () {
-  yield paraCoreInterface.setup();
+  const eagerPartnerLoad = paraCoreInterface.isPortal() ? Promise.resolve() : paraCoreInterface.sessionManagementService.touchSession().catch((e) => {
+    paraCoreInterface.devLog("setupPara: eager partner load via touchSession failed; will retry lazily", e);
+  });
+  yield Promise.all([paraCoreInterface.setup(), eagerPartnerLoad]);
 }));
 export {
   createSetupParaActor

package/dist/esm/state/machines/walletStateMachine.js

@@ -161,6 +161,28 @@ function createWalletStateMachine(paraCoreInterface) {
         ]
       },
       needs_wallets: {
+        // `needs_wallets` is otherwise a passive state that waits for the consumer
+        // to dispatch `WAIT_FOR_WALLET_CREATION`. That contract is fine for
+        // `isNewUser` reaching this state without auto-create (`checking_wallet_state`
+        // guard at line ~127), but it traps existing users who landed here via
+        // `waiting_for_wallets` COMPLETE with `needsWallet=true` — i.e., an
+        // authenticated user whose wallets don't satisfy the partner's
+        // `supportedWalletTypes` (e.g. EVM-only user logging into a Solana-only
+        // partner). Their auth flow set `shouldAutoCreateWallets: true` via
+        // `authenticateWithOAuth` / `authenticateWithEmailOrPhone`, but the
+        // existing `claiming_wallets` guard requires `isNewUser ||
+        // shouldClaimGuestWallets`, neither of which is true for them, so
+        // auto-create silently never happens.
+        //
+        // When `shouldAutoCreate` is true, route directly to `creating_wallets`.
+        // `createWalletPerType` is partner-aware via `#getMissingTypes`, so it
+        // provisions exactly the missing required types (no duplicates).
+        always: [
+          {
+            target: "creating_wallets",
+            guard: "shouldAutoCreate"
+          }
+        ],
         on: {
           WAIT_FOR_WALLET_CREATION: {
             target: "claiming_wallets",

package/dist/esm/telemetry/init.js

@@ -0,0 +1,118 @@
+import {
+  __async,
+  __spreadValues
+} from "../chunk-7B52C2XE.js";
+import { BatchSpanProcessor, BasicTracerProvider, TraceIdRatioBasedSampler } from "@opentelemetry/sdk-trace-base";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from "@opentelemetry/semantic-conventions";
+import { context, propagation, trace } from "@opentelemetry/api";
+import { CompositePropagator, W3CTraceContextPropagator } from "@opentelemetry/core";
+import { UxStateSpanProcessor } from "./uxStateSpanProcessor.js";
+import { UxBaggagePropagator } from "./uxBaggagePropagator.js";
+let initialized = false;
+let tracerProvider;
+const readyCallbacks = [];
+function onTelemetryReady(cb) {
+  if (initialized) {
+    cb();
+    return;
+  }
+  readyCallbacks.push(cb);
+}
+function initTelemetry(opts) {
+  return __async(this, null, function* () {
+    if (initialized) return;
+    initialized = true;
+    const isWeb = opts.sdkType === "WEB" && typeof window !== "undefined";
+    if (isWeb && !opts.isPortal) {
+      try {
+        const { ZoneContextManager } = yield import("@opentelemetry/context-zone");
+        const zoneManager = new ZoneContextManager().enable();
+        context.setGlobalContextManager(zoneManager);
+      } catch (e) {
+      }
+    }
+    const resource = resourceFromAttributes(__spreadValues(__spreadValues({
+      [ATTR_SERVICE_NAME]: opts.isPortal ? "para-portal" : "para-sdk",
+      [ATTR_SERVICE_VERSION]: opts.sdkVersion,
+      "para.platform": opts.sdkType
+    }, opts.partnerId ? { "para.partner_id": opts.partnerId } : {}), opts.resourceAttributes));
+    const exporter = new OTLPTraceExporter({
+      url: opts.tunnelUrl
+      // No auth header — the tunnel is a dumb proxy. Per-IP rate limit + body cap on the
+      // BE side keep abuse contained.
+    });
+    const sampler = new TraceIdRatioBasedSampler(Math.max(0, Math.min(1, opts.sampleRate)));
+    tracerProvider = new BasicTracerProvider({
+      resource,
+      sampler,
+      spanProcessors: [new UxStateSpanProcessor(), new BatchSpanProcessor(exporter)]
+    });
+    trace.setGlobalTracerProvider(tracerProvider);
+    propagation.setGlobalPropagator(
+      new CompositePropagator({
+        propagators: [new W3CTraceContextPropagator(), new UxBaggagePropagator()]
+      })
+    );
+    if (isWeb) {
+      try {
+        const [{ registerInstrumentations }, { FetchInstrumentation }, { XMLHttpRequestInstrumentation }] = yield Promise.all([
+          import("@opentelemetry/instrumentation"),
+          import("@opentelemetry/instrumentation-fetch"),
+          import("@opentelemetry/instrumentation-xml-http-request")
+        ]);
+        const propagateTraceHeaderCorsUrls = [
+          /^https?:\/\/api\.[^/]*getpara\.com/,
+          /^https?:\/\/api\.[^/]*usecapsule\.com/
+        ];
+        if (opts.isDev) {
+          propagateTraceHeaderCorsUrls.push(/^https?:\/\/localhost/);
+        }
+        registerInstrumentations({
+          // Both fetch and XHR are instrumented because axios uses XHR by default in
+          // the browser and `window.fetch` for first-party SDK code paths that opt in.
+          // Without XHR instrumentation, axios calls don't produce client spans AND
+          // Zone-tracked traceparent injection through our manual interceptor isn't
+          // always reliable on native async/await — the auto-instrumentation handles
+          // both span creation and W3C propagation in one pass.
+          instrumentations: [
+            new FetchInstrumentation({ propagateTraceHeaderCorsUrls }),
+            new XMLHttpRequestInstrumentation({ propagateTraceHeaderCorsUrls })
+          ]
+        });
+      } catch (e) {
+      }
+    }
+    while (readyCallbacks.length) {
+      const cb = readyCallbacks.shift();
+      try {
+        cb();
+      } catch (e) {
+      }
+    }
+  });
+}
+function isTelemetryInitialized() {
+  return initialized;
+}
+function flushTelemetry() {
+  return __async(this, null, function* () {
+    if (!tracerProvider) return;
+    try {
+      yield tracerProvider.forceFlush();
+    } catch (e) {
+    }
+  });
+}
+function __resetTelemetryForTests() {
+  initialized = false;
+  tracerProvider = void 0;
+}
+export {
+  __resetTelemetryForTests,
+  flushTelemetry,
+  initTelemetry,
+  isTelemetryInitialized,
+  onTelemetryReady
+};

package/dist/esm/telemetry/modalSession.js

@@ -0,0 +1,29 @@
+import "../chunk-7B52C2XE.js";
+import { context as otelContext, trace } from "@opentelemetry/api";
+const TRACER_NAME = "para-sdk";
+let activeSpan;
+let activeCtx;
+function startModalSession() {
+  if (activeSpan) return;
+  activeSpan = trace.getTracer(TRACER_NAME).startSpan("ui.modal.session");
+  activeCtx = trace.setSpan(otelContext.active(), activeSpan);
+}
+function endModalSession() {
+  activeSpan == null ? void 0 : activeSpan.end();
+  activeSpan = void 0;
+  activeCtx = void 0;
+}
+function getModalSessionContext() {
+  return activeCtx;
+}
+function __resetModalSessionForTests() {
+  activeSpan == null ? void 0 : activeSpan.end();
+  activeSpan = void 0;
+  activeCtx = void 0;
+}
+export {
+  __resetModalSessionForTests,
+  endModalSession,
+  getModalSessionContext,
+  startModalSession
+};

package/dist/esm/telemetry/session.js

@@ -0,0 +1,16 @@
+import "../chunk-7B52C2XE.js";
+import { v4 as uuidv4 } from "uuid";
+let sessionId;
+function getOrCreateSessionId() {
+  if (!sessionId) {
+    sessionId = uuidv4();
+  }
+  return sessionId;
+}
+function __resetSessionForTests() {
+  sessionId = void 0;
+}
+export {
+  __resetSessionForTests,
+  getOrCreateSessionId
+};

package/dist/esm/telemetry/tracer.js

@@ -0,0 +1,84 @@
+import {
+  __async
+} from "../chunk-7B52C2XE.js";
+import {
+  context as otelContext,
+  propagation,
+  SpanStatusCode,
+  trace
+} from "@opentelemetry/api";
+import { getModalSessionContext } from "./modalSession.js";
+const TRACER_NAME = "para-sdk";
+function getTracer() {
+  return trace.getTracer(TRACER_NAME);
+}
+let defaultParentContext;
+function setDefaultParentContext(ctx) {
+  defaultParentContext = ctx;
+}
+function getDefaultParentContext() {
+  return defaultParentContext;
+}
+function wrapWithSpan(name, fn, attributes) {
+  return __async(this, null, function* () {
+    var _a, _b;
+    const active = otelContext.active();
+    const activeSpan = trace.getSpan(active);
+    const parentCtx = activeSpan ? active : (_b = (_a = getModalSessionContext()) != null ? _a : defaultParentContext) != null ? _b : active;
+    return otelContext.with(
+      parentCtx,
+      () => getTracer().startActiveSpan(name, { attributes }, (span) => __async(this, null, function* () {
+        try {
+          const result = yield fn(span);
+          return result;
+        } catch (err) {
+          span.recordException(err);
+          span.setStatus({ code: SpanStatusCode.ERROR, message: err.message });
+          throw err;
+        } finally {
+          span.end();
+        }
+      }))
+    );
+  });
+}
+function extractTraceContextFromUrl(search) {
+  return propagation.extract(otelContext.active(), getUrlTraceCarrier(search));
+}
+function getUrlTraceCarrier(search) {
+  const url = search != null ? search : typeof window !== "undefined" ? window.location.search : "";
+  const params = new URLSearchParams(url);
+  const carrier = {};
+  const tp = params.get("traceparent");
+  const ts = params.get("tracestate");
+  if (tp) carrier.traceparent = tp;
+  if (ts) carrier.tracestate = ts;
+  return carrier;
+}
+function wrapWithSpanInContext(parentContext, name, fn) {
+  return __async(this, null, function* () {
+    return otelContext.with(
+      parentContext,
+      () => wrapWithSpan(name, (span) => {
+        const traceHeaders = {};
+        propagation.inject(otelContext.active(), traceHeaders, {
+          set: (carrier, key, value) => {
+            carrier[key] = value;
+          }
+        });
+        return fn(span, traceHeaders);
+      })
+    );
+  });
+}
+import { SpanStatusCode as SpanStatusCode2 } from "@opentelemetry/api";
+export {
+  SpanStatusCode2 as SpanStatusCode,
+  extractTraceContextFromUrl,
+  getDefaultParentContext,
+  getTracer,
+  getUrlTraceCarrier,
+  setDefaultParentContext,
+  wrapWithSpan,
+  wrapWithSpanInContext
+};

package/dist/esm/telemetry/uxAction.js

@@ -0,0 +1,8 @@
+import "../chunk-7B52C2XE.js";
+function recordActionOnSpan(span, targetId, outcome) {
+  span.setAttribute("ui.target_id", targetId);
+  span.setAttribute("ui.outcome", outcome);
+}
+export {
+  recordActionOnSpan
+};

package/dist/esm/telemetry/uxBaggagePropagator.js

@@ -0,0 +1,35 @@
+import {
+  __privateAdd,
+  __privateGet
+} from "../chunk-7B52C2XE.js";
+var _inner;
+import {
+  propagation
+} from "@opentelemetry/api";
+import { W3CBaggagePropagator } from "@opentelemetry/core";
+import { getUxState } from "./uxState.js";
+import { getOrCreateSessionId } from "./session.js";
+class UxBaggagePropagator {
+  constructor() {
+    __privateAdd(this, _inner, new W3CBaggagePropagator());
+  }
+  inject(ctx, carrier, setter) {
+    var _a;
+    const state = getUxState();
+    let bag = (_a = propagation.getBaggage(ctx)) != null ? _a : propagation.createBaggage();
+    bag = bag.setEntry("ui.session_id", { value: getOrCreateSessionId() });
+    if (state.view) bag = bag.setEntry("ui.view", { value: state.view });
+    if (state.lastInteraction) bag = bag.setEntry("ui.last_interaction", { value: state.lastInteraction });
+    __privateGet(this, _inner).inject(propagation.setBaggage(ctx, bag), carrier, setter);
+  }
+  extract(ctx, carrier, getter) {
+    return __privateGet(this, _inner).extract(ctx, carrier, getter);
+  }
+  fields() {
+    return __privateGet(this, _inner).fields();
+  }
+}
+_inner = new WeakMap();
+export {
+  UxBaggagePropagator
+};

package/dist/esm/telemetry/uxState.js

@@ -0,0 +1,21 @@
+import "../chunk-7B52C2XE.js";
+const state = {};
+function getUxState() {
+  return state;
+}
+function setCurrentView(view) {
+  state.view = view;
+}
+function setLastInteraction(targetId) {
+  state.lastInteraction = targetId;
+}
+function __resetUxStateForTests() {
+  state.view = void 0;
+  state.lastInteraction = void 0;
+}
+export {
+  __resetUxStateForTests,
+  getUxState,
+  setCurrentView,
+  setLastInteraction
+};

package/dist/esm/telemetry/uxStateSpanProcessor.js

@@ -0,0 +1,28 @@
+import "../chunk-7B52C2XE.js";
+import { getUxState } from "./uxState.js";
+import { getOrCreateSessionId } from "./session.js";
+let currentUserId;
+function setCurrentUserId(userId) {
+  currentUserId = userId;
+}
+class UxStateSpanProcessor {
+  onStart(span, _parentContext) {
+    const state = getUxState();
+    span.setAttribute("ui.session_id", getOrCreateSessionId());
+    if (currentUserId) span.setAttribute("user.id", currentUserId);
+    if (state.view) span.setAttribute("ui.view", state.view);
+    if (state.lastInteraction) span.setAttribute("ui.last_interaction", state.lastInteraction);
+  }
+  onEnd() {
+  }
+  forceFlush() {
+    return Promise.resolve();
+  }
+  shutdown() {
+    return Promise.resolve();
+  }
+}
+export {
+  UxStateSpanProcessor,
+  setCurrentUserId
+};

package/dist/esm/utils/configEncoding.js

@@ -0,0 +1,45 @@
+import {
+  __async
+} from "../chunk-7B52C2XE.js";
+import { Buffer } from "buffer";
+import base64url from "base64url";
+const ENCODED_CONFIG_VERSION = 1;
+function isCompressionStreamSupported() {
+  return typeof CompressionStream !== "undefined" && typeof DecompressionStream !== "undefined";
+}
+function encodeConfigParams(config) {
+  return __async(this, null, function* () {
+    if (!isCompressionStreamSupported()) return null;
+    try {
+      const json = JSON.stringify(config);
+      const stream = new Blob([json]).stream().pipeThrough(new CompressionStream("gzip"));
+      const compressed = new Uint8Array(yield new Response(stream).arrayBuffer());
+      return base64url.encode(Buffer.from(compressed));
+    } catch (e) {
+      return null;
+    }
+  });
+}
+function tryDecodeConfig(s) {
+  return __async(this, null, function* () {
+    if (!isCompressionStreamSupported()) return null;
+    if (!/^[A-Za-z0-9_-]+$/.test(s)) return null;
+    try {
+      const compressed = base64url.toBuffer(s);
+      const stream = new Blob([compressed]).stream().pipeThrough(new DecompressionStream("gzip"));
+      const json = yield new Response(stream).text();
+      const parsed = JSON.parse(json);
+      if (!parsed || typeof parsed !== "object") return null;
+      if (parsed.v !== ENCODED_CONFIG_VERSION) return null;
+      return parsed;
+    } catch (e) {
+      return null;
+    }
+  });
+}
+export {
+  ENCODED_CONFIG_VERSION,
+  encodeConfigParams,
+  isCompressionStreamSupported,
+  tryDecodeConfig
+};

package/dist/esm/utils/deprecation.js

@@ -1,16 +1,15 @@
 import "../chunk-7B52C2XE.js";
-const MIGRATION_GUIDE_URL = "https://docs.getpara.com/v2/rest/migrate-from-sdk-pregen";
-const warned = /* @__PURE__ */ new Set();
-function warnPregenDeprecation(methodName) {
-  if (warned.has(methodName)) return;
-  warned.add(methodName);
-  console.warn(
-    `[Para] ${methodName}() is deprecated and will be removed in a future release.
-  \u2192 New integrations: use the REST API instead
-  \u2192 Existing wallets: use para.migrateWalletShare() to migrate
-  \u2192 Guide: ${MIGRATION_GUIDE_URL}`
-  );
+const warnedScopedKeys = /* @__PURE__ */ new Set();
+function warnOnce(scope, key, message) {
+  const fullKey = `${scope}::${key}`;
+  if (warnedScopedKeys.has(fullKey)) return;
+  warnedScopedKeys.add(fullKey);
+  console.warn(`[Para] ${message}`);
+}
+function _resetWarnOnceForTests() {
+  warnedScopedKeys.clear();
 }
 export {
-  warnPregenDeprecation
+  _resetWarnOnceForTests,
+  warnOnce
 };

package/dist/esm/utils/index.js

@@ -1,13 +1,19 @@
+import "../chunk-7B52C2XE.js";
 export * from "./autobind.js";
 export * from "./config.js";
+import { warnOnce } from "./deprecation.js";
 export * from "./events.js";
 export * from "./formatting.js";
 export * from "./json.js";
 export * from "./listeners.js";
 export * from "./onRamps.js";
+export * from "./partnerConfig.js";
 export * from "./phone.js";
 export * from "./polling.js";
 export * from "./types.js";
 export * from "./url.js";
 export * from "./wallet.js";
 export * from "./window.js";
+export {
+  warnOnce
+};