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

package/dist/esm/services/PregenWalletService.js

@@ -6,7 +6,7 @@ import {
   __spreadProps,
   __spreadValues
 } from "../chunk-7B52C2XE.js";
-var _stateManager, _authService, _walletService, _pollingService, _paraCoreInterface, _isCreateGuestWalletsPending, _fetchOverridePromise;
+var _stateManager, _authService, _walletService, _pollingService, _paraCoreInterface, _isCreateGuestWalletsPending, _fetchOverridePromise, _claimPregenWalletEntities;
 import {
   isPregenAuth,
   toPregenIds,
@@ -23,6 +23,7 @@ import { dispatchEvent } from "../utils/index.js";
 import { ParaEvent } from "../types/events.js";
 import { distributeNewShare } from "../shares/shareDistribution.js";
 import { SHORT_POLLING_INTERVAL_MS } from "../constants.js";
+import { wrapWithSpan } from "../telemetry/tracer.js";
 import { waitForCoreStateChange } from "../utils/stateListener.js";
 class PregenWalletService {
   constructor(paraCore) {
@@ -81,37 +82,50 @@ class PregenWalletService {
       }
       const { supportedWalletTypes } = yield __privateGet(this, _paraCoreInterface).assertPartner();
       const pregenWallets = yield this.getPregenWallets();
-      let recoverySecret, walletIds = {};
+      let recoverySecret;
+      let walletIds = {};
       if (pregenWallets.length > 0) {
-        try {
-          const shares = yield __privateGet(this, _paraCoreInterface).ctx.enclaveClient.getPregenShares({
-            userId: __privateGet(this, _authService).userId,
-            walletIds: pregenWallets.map((w) => w.id),
-            partnerId: pregenWallets[0].partnerId
-          });
-          for (const share of shares) {
-            const wallet = pregenWallets.find((w) => w.id === share.walletId);
-            if (wallet) {
-              __privateGet(this, _walletService).wallets[wallet.id] = {
-                id: wallet.id,
-                address: wallet.address,
-                scheme: wallet.scheme,
-                type: wallet.type,
-                partnerId: wallet.partnerId,
-                isPregen: wallet.isPregen,
-                pregenIdentifier: wallet.pregenIdentifier,
-                pregenIdentifierType: wallet.pregenIdentifierType,
-                signer: share.signer,
-                createdAt: String(wallet.createdAt)
-              };
+        let candidates = pregenWallets.filter((w) => {
+          var _a;
+          return !!((_a = __privateGet(this, _walletService).wallets[w.id]) == null ? void 0 : _a.signer);
+        });
+        if (candidates.length === 0) {
+          try {
+            const shares = yield __privateGet(this, _paraCoreInterface).ctx.enclaveClient.getPregenShares({
+              userId: __privateGet(this, _authService).userId,
+              walletIds: pregenWallets.map((w) => w.id),
+              partnerId: pregenWallets[0].partnerId
+            });
+            for (const share of shares) {
+              const wallet = pregenWallets.find((w) => w.id === share.walletId);
+              if (wallet) {
+                __privateGet(this, _walletService).wallets[wallet.id] = {
+                  id: wallet.id,
+                  address: wallet.address,
+                  scheme: wallet.scheme,
+                  type: wallet.type,
+                  partnerId: wallet.partnerId,
+                  isPregen: wallet.isPregen,
+                  pregenIdentifier: wallet.pregenIdentifier,
+                  pregenIdentifierType: wallet.pregenIdentifierType,
+                  signer: share.signer,
+                  createdAt: String(wallet.createdAt)
+                };
+              }
             }
+          } catch (err) {
+            console.warn("[performClaimPregenWallets] Failed to fetch pregen shares:", err);
           }
-        } catch (err) {
-          console.warn("[performClaimPregenWallets] Failed to fetch pregen shares:", err);
+          candidates = pregenWallets.filter((w) => {
+            var _a;
+            return !!((_a = __privateGet(this, _walletService).wallets[w.id]) == null ? void 0 : _a.signer);
+          });
         }
-        recoverySecret = yield this.claimPregenWallets();
+        const { recoverySecret: claimRecoverySecret, claimedWalletIds } = yield __privateGet(this, _claimPregenWalletEntities).call(this, candidates);
+        recoverySecret = claimRecoverySecret;
+        const claimed = candidates.filter((w) => claimedWalletIds.includes(w.id));
         walletIds = supportedWalletTypes.reduce((acc, { type }) => {
-          const wallet = pregenWallets.find((w) => !!WalletSchemeTypeMap[w.scheme][type]);
+          const wallet = claimed.find((w) => !!WalletSchemeTypeMap[w.scheme][type]);
           if (!wallet) {
             return acc;
           }
@@ -125,48 +139,76 @@ class PregenWalletService {
       return resp;
     });
     this.claimPregenWallets = (..._0) => __async(this, [..._0], function* ({ pregenId } = {}) {
-      var _a;
       __privateGet(this, _paraCoreInterface).requireApiKey();
       const pregenWallets = pregenId ? yield this.getPregenWallets({ pregenId }) : yield this.getPregenWallets();
       if (pregenWallets.length === 0) {
         return void 0;
       }
-      const missingWallets = pregenWallets.filter((wallet) => !__privateGet(this, _walletService).wallets[wallet.id]);
-      if (missingWallets.length > 0) {
-        throw new Error(
-          `Cannot claim pregen wallets because wallet data is missing. Please call setUserShare first to load the wallet data for the following wallet IDs: ${missingWallets.map((w) => w.id).join(", ")}`
+      const { recoverySecret } = yield __privateGet(this, _claimPregenWalletEntities).call(this, pregenWallets);
+      return recoverySecret;
+    });
+    // Claims only the pregen entities for which the SDK has local signer
+    // material. Wallets without signer material are skipped (warned, not
+    // thrown) so a stale/duplicate backend row cannot block login.
+    // Returns the wallet IDs the backend confirmed claiming so callers can
+    // surface only confirmed wallets.
+    __privateAdd(this, _claimPregenWalletEntities, (pregenWallets) => __async(this, null, function* () {
+      var _a;
+      const claimable = pregenWallets.filter((w) => {
+        var _a2;
+        return !!((_a2 = __privateGet(this, _walletService).wallets[w.id]) == null ? void 0 : _a2.signer);
+      });
+      const skipped = pregenWallets.filter((w) => {
+        var _a2;
+        return !((_a2 = __privateGet(this, _walletService).wallets[w.id]) == null ? void 0 : _a2.signer);
+      });
+      if (skipped.length > 0) {
+        console.warn(
+          "[claimPregenWallets] Skipping pregen wallets without local share material:",
+          skipped.map((w) => w.id)
         );
       }
+      if (claimable.length === 0) {
+        return { recoverySecret: void 0, claimedWalletIds: [] };
+      }
       let newRecoverySecret;
       const { walletIds } = yield __privateGet(this, _paraCoreInterface).ctx.client.claimPregenWallets({
         userId: __privateGet(this, _authService).userId,
-        walletIds: pregenWallets.map((w) => w.id)
+        walletIds: claimable.map((w) => w.id)
       });
       for (const walletId of walletIds) {
         const wallet = __privateGet(this, _walletService).wallets[walletId];
         let refreshedShare;
         if (wallet.scheme === "ED25519") {
-          const distributeRes = yield distributeNewShare({
-            ctx: __privateGet(this, _paraCoreInterface).ctx,
-            userId: __privateGet(this, _authService).userId,
-            walletId: wallet.id,
-            userShare: __privateGet(this, _walletService).wallets[wallet.id].signer,
-            emailProps: __privateGet(this, _paraCoreInterface).getBackupKitEmailProps(),
-            partnerId: wallet.partnerId,
-            isEnclaveUser: __privateGet(this, _authService).isEnclaveUser,
-            walletScheme: wallet.scheme
-          });
+          const distributeRes = yield wrapWithSpan(
+            "mpc.claim",
+            () => distributeNewShare({
+              ctx: __privateGet(this, _paraCoreInterface).ctx,
+              userId: __privateGet(this, _authService).userId,
+              walletId: wallet.id,
+              userShare: __privateGet(this, _walletService).wallets[wallet.id].signer,
+              emailProps: __privateGet(this, _paraCoreInterface).getBackupKitEmailProps(),
+              partnerId: wallet.partnerId,
+              isEnclaveUser: __privateGet(this, _authService).isEnclaveUser,
+              walletScheme: wallet.scheme
+            }),
+            { "wallet.id": wallet.id, "wallet.scheme": "ED25519" }
+          );
           if (distributeRes.length > 0) {
             newRecoverySecret = distributeRes;
           }
         } else {
-          refreshedShare = yield __privateGet(this, _walletService).refreshShare({
-            walletId: wallet.id,
-            share: __privateGet(this, _walletService).wallets[wallet.id].signer,
-            oldPartnerId: wallet.partnerId,
-            newPartnerId: wallet.partnerId,
-            redistributeBackupEncryptedShares: true
-          });
+          refreshedShare = yield wrapWithSpan(
+            "mpc.claim",
+            () => __privateGet(this, _walletService).refreshShare({
+              walletId: wallet.id,
+              share: __privateGet(this, _walletService).wallets[wallet.id].signer,
+              oldPartnerId: wallet.partnerId,
+              newPartnerId: wallet.partnerId,
+              redistributeBackupEncryptedShares: true
+            }),
+            { "wallet.id": wallet.id, "wallet.scheme": wallet.scheme }
+          );
           if (refreshedShare.recoverySecret) {
             newRecoverySecret = refreshedShare.recoverySecret;
           }
@@ -185,8 +227,8 @@ class PregenWalletService {
         });
       }
       yield __privateGet(this, _walletService).setWallets(__privateGet(this, _walletService).wallets);
-      return newRecoverySecret;
-    });
+      return { recoverySecret: newRecoverySecret, claimedWalletIds: walletIds };
+    }));
     this.getPregenWallets = (..._0) => __async(this, [..._0], function* ({ pregenId } = {}) {
       const pregenIds = pregenId ? toPregenIds(pregenId) : this.pregenIds;
       if (!pregenIds || Object.keys(pregenIds).length === 0) {
@@ -218,30 +260,36 @@ class PregenWalletService {
         _type != null ? _type : (_b = supportedWalletTypes.find(({ optional }) => !optional)) == null ? void 0 : _b.type
       );
       const [pregenIdentifierType, pregenIdentifier] = toPregenTypeAndId(pregenId);
-      let keygenRes;
-      switch (walletType) {
-        case "STELLAR":
-        case "SOLANA":
-          keygenRes = yield __privateGet(this, _paraCoreInterface).platformUtils.ed25519PreKeygen(
-            __privateGet(this, _paraCoreInterface).ctx,
-            pregenIdentifier,
-            pregenIdentifierType,
-            __privateGet(this, _paraCoreInterface).retrieveSessionCookie(),
-            walletType
-          );
-          break;
-        default:
-          keygenRes = yield __privateGet(this, _paraCoreInterface).platformUtils.preKeygen(
-            __privateGet(this, _paraCoreInterface).ctx,
-            void 0,
-            pregenIdentifier,
-            pregenIdentifierType,
-            walletType,
-            null,
-            __privateGet(this, _paraCoreInterface).retrieveSessionCookie()
-          );
-          break;
-      }
+      const keygenRes = yield wrapWithSpan(
+        "mpc.keygen",
+        () => __async(this, null, function* () {
+          switch (walletType) {
+            case "STELLAR":
+            case "SOLANA":
+              return __privateGet(this, _paraCoreInterface).platformUtils.ed25519PreKeygen(
+                __privateGet(this, _paraCoreInterface).ctx,
+                pregenIdentifier,
+                pregenIdentifierType,
+                __privateGet(this, _paraCoreInterface).retrieveSessionCookie(),
+                walletType
+              );
+            default:
+              return __privateGet(this, _paraCoreInterface).platformUtils.preKeygen(
+                __privateGet(this, _paraCoreInterface).ctx,
+                void 0,
+                pregenIdentifier,
+                pregenIdentifierType,
+                walletType,
+                null,
+                __privateGet(this, _paraCoreInterface).retrieveSessionCookie()
+              );
+          }
+        }),
+        {
+          "wallet.type": walletType,
+          "wallet.scheme": walletType === "SOLANA" || walletType === "STELLAR" ? "ED25519" : "DKLS"
+        }
+      );
       const { signer, walletId } = keygenRes;
       __privateGet(this, _walletService).wallets[walletId] = {
         id: walletId,
@@ -390,6 +438,7 @@ _pollingService = new WeakMap();
 _paraCoreInterface = new WeakMap();
 _isCreateGuestWalletsPending = new WeakMap();
 _fetchOverridePromise = new WeakMap();
+_claimPregenWalletEntities = new WeakMap();
 export {
   PregenWalletService
 };

package/dist/esm/services/SessionManagementService.js

@@ -2,11 +2,13 @@ import {
   __async,
   __privateAdd,
   __privateGet,
-  __privateSet
+  __privateSet,
+  __spreadValues
 } from "../chunk-7B52C2XE.js";
-var _authService, _portalUrlService, _walletService, _pregenWalletService, _externalWalletService, _paraCoreInterface, _isImportedSession, _regeneratePromise, _handleTouchSessionError, _doTouchSession;
+var _authService, _portalUrlService, _walletService, _pregenWalletService, _externalWalletService, _paraCoreInterface, _isImportedSession, _regeneratePromise, _touchPromise, _touchCachedAt, _touchCached, _TOUCH_TTL_MS, _handleTouchSessionError, _shouldDedupeTouch, _doTouchSession;
 import { currentWalletIdsEq, supportedWalletTypesEq } from "../utils/wallet.js";
-class SessionManagementService {
+import { wrapWithSpan } from "../telemetry/tracer.js";
+const _SessionManagementService = class _SessionManagementService {
   constructor(paraCore) {
     __privateAdd(this, _authService);
     __privateAdd(this, _portalUrlService);
@@ -16,6 +18,21 @@ class SessionManagementService {
     __privateAdd(this, _paraCoreInterface);
     __privateAdd(this, _isImportedSession);
     __privateAdd(this, _regeneratePromise);
+    // In-flight + short TTL dedupe for touchSession(regenerate=false). Prevents
+    // the post-login storm where useIsFullyLoggedIn → isFullyLoggedIn →
+    // isSessionActive → touchSession() fires once per render across many
+    // consumers (we observed 68 /touch round-trips in a 663ms window during
+    // AccountReady). The result is still authoritative — just shared across
+    // concurrent and immediately-following callers instead of refetched per call.
+    //
+    // IMPORTANT: this is disabled in the portal (see #shouldDedupeTouch). The
+    // portal reuses this same service and depends on touchSession() running its
+    // side-effects (currentWalletIds / partner sync) and returning fresh state on
+    // every sequential poll; a previous unconditional version of this cache
+    // (eb8e5f843, reverted in 58c8dadd6) broke that portal flow.
+    __privateAdd(this, _touchPromise);
+    __privateAdd(this, _touchCachedAt);
+    __privateAdd(this, _touchCached);
     this.init = ({
       authService,
       portalUrlService,
@@ -53,14 +70,48 @@ class SessionManagementService {
       if (regenerate && __privateGet(this, _regeneratePromise) !== void 0) {
         return __privateGet(this, _regeneratePromise);
       }
-      const promise = __privateGet(this, _doTouchSession).call(this, regenerate);
-      if (regenerate) {
-        __privateSet(this, _regeneratePromise, promise);
-        yield promise.finally(() => {
-          __privateSet(this, _regeneratePromise, void 0);
-        });
+      const dedupe = __privateGet(this, _shouldDedupeTouch).call(this, regenerate);
+      if (dedupe) {
+        if (__privateGet(this, _touchPromise) !== void 0) {
+          return __privateGet(this, _touchPromise);
+        }
+        if (__privateGet(this, _touchCached) !== void 0 && __privateGet(this, _touchCachedAt) !== void 0 && Date.now() - __privateGet(this, _touchCachedAt) < __privateGet(_SessionManagementService, _TOUCH_TTL_MS)) {
+          return __spreadValues({}, __privateGet(this, _touchCached));
+        }
       }
-      return promise;
+      return wrapWithSpan(
+        "session.touch",
+        () => __async(this, null, function* () {
+          const promise = __privateGet(this, _doTouchSession).call(this, regenerate);
+          if (regenerate) {
+            __privateSet(this, _regeneratePromise, promise);
+            yield promise.finally(() => {
+              __privateSet(this, _regeneratePromise, void 0);
+              __privateSet(this, _touchCached, void 0);
+              __privateSet(this, _touchCachedAt, void 0);
+            });
+          } else if (dedupe) {
+            __privateSet(this, _touchPromise, promise);
+            try {
+              const result = yield promise;
+              if (result.userId) {
+                __privateSet(this, _touchCached, result);
+                __privateSet(this, _touchCachedAt, Date.now());
+              }
+            } finally {
+              __privateSet(this, _touchPromise, void 0);
+            }
+          }
+          return promise;
+        }),
+        { "session.regenerate": regenerate }
+      );
+    });
+    // Whether the non-regenerate dedupe/cache should apply. Disabled in the portal,
+    // which depends on every touchSession() call running its side-effects and
+    // returning fresh session state (see #touchCached docs).
+    __privateAdd(this, _shouldDedupeTouch, (regenerate) => {
+      return !regenerate && !__privateGet(this, _paraCoreInterface).isPortal();
     });
     __privateAdd(this, _doTouchSession, (regenerate) => __async(this, null, function* () {
       var _a, _b;
@@ -220,7 +271,7 @@ class SessionManagementService {
   set isImportedSession(value) {
     __privateSet(this, _isImportedSession, value);
   }
-}
+};
 _authService = new WeakMap();
 _portalUrlService = new WeakMap();
 _walletService = new WeakMap();
@@ -229,8 +280,15 @@ _externalWalletService = new WeakMap();
 _paraCoreInterface = new WeakMap();
 _isImportedSession = new WeakMap();
 _regeneratePromise = new WeakMap();
+_touchPromise = new WeakMap();
+_touchCachedAt = new WeakMap();
+_touchCached = new WeakMap();
+_TOUCH_TTL_MS = new WeakMap();
 _handleTouchSessionError = new WeakMap();
+_shouldDedupeTouch = new WeakMap();
 _doTouchSession = new WeakMap();
+__privateAdd(_SessionManagementService, _TOUCH_TTL_MS, 1e3);
+let SessionManagementService = _SessionManagementService;
 export {
   SessionManagementService
 };

package/dist/esm/services/SignupFlowService.js

@@ -10,6 +10,7 @@ import { ParaEvent } from "../types/index.js";
 import { dispatchEvent } from "../utils/index.js";
 import { extractErrorMessage } from "../utils/stateErrorHelpers.js";
 import { waitForAuthStateChange, waitForCoreStateChange } from "../utils/stateListener.js";
+import { wrapWithSpan } from "../telemetry/tracer.js";
 class SignupFlowService extends BaseAuthFlowService {
   constructor() {
     super(...arguments);
@@ -74,58 +75,62 @@ class SignupFlowService extends BaseAuthFlowService {
       return signupState;
     });
     this.waitForSignup = (_0) => __async(this, [_0], function* ({ isCanceled = () => false, onCancel, onPoll }) {
-      this.stateManager.send({
-        type: "WAIT_FOR_SESSION",
-        data: {
-          onCancel,
-          onPoll,
-          isCanceled
-        }
-      });
-      return yield waitForAuthStateChange({
-        stateManager: this.stateManager,
-        resolvePhases: [
-          {
-            phase: "authenticated",
-            onPhase: () => {
-              dispatchEvent(ParaEvent.ACCOUNT_CREATION_EVENT, true);
-              return true;
-            }
+      return wrapWithSpan("auth.signup_wait", () => __async(this, null, function* () {
+        this.stateManager.send({
+          type: "WAIT_FOR_SESSION",
+          data: {
+            onCancel,
+            onPoll,
+            isCanceled
           }
-        ],
-        onReject: (state) => {
-          var _a;
-          (_a = dispatchEvent) == null ? void 0 : _a(ParaEvent.ACCOUNT_CREATION_EVENT, {}, extractErrorMessage(state.error, "failed to sign up user"));
-        },
-        waitForCoreAuthenticated: false
-      });
+        });
+        return yield waitForAuthStateChange({
+          stateManager: this.stateManager,
+          resolvePhases: [
+            {
+              phase: "authenticated",
+              onPhase: () => {
+                dispatchEvent(ParaEvent.ACCOUNT_CREATION_EVENT, true);
+                return true;
+              }
+            }
+          ],
+          onReject: (state) => {
+            var _a;
+            (_a = dispatchEvent) == null ? void 0 : _a(ParaEvent.ACCOUNT_CREATION_EVENT, {}, extractErrorMessage(state.error, "failed to sign up user"));
+          },
+          waitForCoreAuthenticated: false
+        });
+      }));
     });
     this.waitForWalletCreation = (..._0) => __async(this, [..._0], function* ({ isCanceled = () => false, onCancel, onPoll } = {}) {
-      this.stateManager.send({
-        type: "WAIT_FOR_WALLET_CREATION",
-        data: {
-          onCancel,
-          onPoll,
-          isCanceled
-        }
-      });
-      return yield waitForCoreStateChange({
-        stateManager: this.stateManager,
-        resolvePhases: [
-          {
-            phase: "authenticated",
-            onPhase: (state) => {
-              const resp = state.newWalletsResult;
-              dispatchEvent(ParaEvent.ACCOUNT_SETUP_EVENT, resp);
-              return resp;
+      return wrapWithSpan("wallet.creation_wait", () => __async(this, null, function* () {
+        this.stateManager.send({
+          type: "WAIT_FOR_WALLET_CREATION",
+          data: {
+            onCancel,
+            onPoll,
+            isCanceled
+          }
+        });
+        return yield waitForCoreStateChange({
+          stateManager: this.stateManager,
+          resolvePhases: [
+            {
+              phase: "authenticated",
+              onPhase: (state) => {
+                const resp = state.newWalletsResult;
+                dispatchEvent(ParaEvent.ACCOUNT_SETUP_EVENT, resp);
+                return resp;
+              }
             }
+          ],
+          onReject: (state) => {
+            var _a;
+            (_a = dispatchEvent) == null ? void 0 : _a(ParaEvent.ACCOUNT_SETUP_EVENT, {}, extractErrorMessage(state.error, "failed to sign up user"));
           }
-        ],
-        onReject: (state) => {
-          var _a;
-          (_a = dispatchEvent) == null ? void 0 : _a(ParaEvent.ACCOUNT_SETUP_EVENT, {}, extractErrorMessage(state.error, "failed to sign up user"));
-        }
-      });
+        });
+      }));
     });
   }
 }

package/dist/esm/services/VerificationFlowService.js

@@ -7,6 +7,7 @@ import { AuthMethod } from "@getpara/user-management-client";
 import { BaseAuthFlowService } from "./BaseAuthFlowService.js";
 import { LOCAL_STORAGE_IS_ENCLAVE_USER } from "../constants.js";
 import { waitForAuthStateChange } from "../utils/stateListener.js";
+import { wrapWithSpan } from "../telemetry/tracer.js";
 class VerificationFlowService extends BaseAuthFlowService {
   constructor() {
     super(...arguments);
@@ -38,16 +39,18 @@ class VerificationFlowService extends BaseAuthFlowService {
       return __spreadValues(__spreadValues({}, serverAuthState), loginUrl ? { loginUrl, loginFullUrl } : {});
     });
     this.performVerifyNewAccount = (params) => __async(this, null, function* () {
-      this.services.authService.assertIsAuthSet(["email", "phone"]);
-      const _a = params, { verificationCode } = _a, urlOptions = __objRest(_a, ["verificationCode"]);
-      const serverAuthState = yield this.paraCoreInterface.ctx.client.verifyAccount(this.services.authService.userId, {
-        verificationCode
-      });
-      if (serverAuthState.stage === "login" || serverAuthState.stage === "done") {
-        throw new Error("Account already exists.");
-      }
-      yield this.services.sessionManagementService.touchSession(true);
-      return { authState: serverAuthState, opts: urlOptions };
+      return wrapWithSpan("verification.verify_otp", () => __async(this, null, function* () {
+        this.services.authService.assertIsAuthSet(["email", "phone"]);
+        const _a = params, { verificationCode } = _a, urlOptions = __objRest(_a, ["verificationCode"]);
+        const serverAuthState = yield this.paraCoreInterface.ctx.client.verifyAccount(this.services.authService.userId, {
+          verificationCode
+        });
+        if (serverAuthState.stage === "login" || serverAuthState.stage === "done") {
+          throw new Error("Account already exists.");
+        }
+        yield this.services.sessionManagementService.touchSession(true);
+        return { authState: serverAuthState, opts: urlOptions };
+      }));
     });
     this.verifyNewAccount = (params) => __async(this, null, function* () {
       this.stateManager.send({ type: "VERIFY_NEW_ACCOUNT", data: params });