@getpara/core-sdk 3.0.0-alpha.0 → 3.0.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

@@ -6,6 +6,7 @@ import {
 } from "../chunk-7B52C2XE.js";
 var _authService, _portalUrlService, _walletService, _pregenWalletService, _externalWalletService, _paraCoreInterface, _isImportedSession, _regeneratePromise, _handleTouchSessionError, _doTouchSession;
 import { currentWalletIdsEq, supportedWalletTypesEq } from "../utils/wallet.js";
+import { wrapWithSpan } from "../telemetry/tracer.js";
 class SessionManagementService {
   constructor(paraCore) {
     __privateAdd(this, _authService);
@@ -53,14 +54,20 @@ 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);
-        });
-      }
-      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);
+            });
+          }
+          return promise;
+        }),
+        { "session.regenerate": regenerate }
+      );
     });
     __privateAdd(this, _doTouchSession, (regenerate) => __async(this, null, function* () {
       var _a, _b;

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 });

package/dist/esm/services/WalletService.js

@@ -28,6 +28,7 @@ import { ParaEvent } from "../types/events.js";
 import { LOCAL_STORAGE_CURRENT_WALLET_IDS, LOCAL_STORAGE_WALLETS, SHORT_POLLING_INTERVAL_MS } from "../constants.js";
 import { distributeNewShare } from "../shares/shareDistribution.js";
 import { sendRecoveryForShare } from "../shares/recovery.js";
+import { wrapWithSpan } from "../telemetry/tracer.js";
 class WalletService {
   constructor(paraCore) {
     __privateAdd(this, _authService);
@@ -108,15 +109,20 @@ class WalletService {
         }
       });
     });
+    // wallets.populate names the GET /users/:userId/wallets call that runs to
+    // refresh address state after creation/refresh; without it the GET shows up
+    // as a bare span at the trace top level.
     this.populateWalletAddresses = () => __async(this, null, function* () {
-      const res = yield (__privateGet(this, _paraCoreInterface).isPortal() ? __privateGet(this, _paraCoreInterface).ctx.client.getAllWallets : __privateGet(this, _paraCoreInterface).ctx.client.getWallets)(__privateGet(this, _authService).userId, true);
-      const wallets = res.data.wallets;
-      wallets.forEach((entity) => {
-        if (this.wallets[entity.id]) {
-          this.wallets[entity.id] = __spreadValues(__spreadValues({}, entityToWallet(entity)), this.wallets[entity.id]);
-        }
-      });
-      yield this.setWallets(this.wallets);
+      return wrapWithSpan("wallets.populate", () => __async(this, null, function* () {
+        const res = yield (__privateGet(this, _paraCoreInterface).isPortal() ? __privateGet(this, _paraCoreInterface).ctx.client.getAllWallets : __privateGet(this, _paraCoreInterface).ctx.client.getWallets)(__privateGet(this, _authService).userId, true);
+        const wallets = res.data.wallets;
+        wallets.forEach((entity) => {
+          if (this.wallets[entity.id]) {
+            this.wallets[entity.id] = __spreadValues(__spreadValues({}, entityToWallet(entity)), this.wallets[entity.id]);
+          }
+        });
+        yield this.setWallets(this.wallets);
+      }));
     });
     this.addToCurrentWalletIds = (walletIds, options) => __async(this, null, function* () {
       const updatedWalletIds = __spreadValues({}, this.currentWalletIds);
@@ -156,31 +162,35 @@ class WalletService {
       );
       let signer;
       let wallet;
-      let keygenRes;
-      switch (walletType) {
-        case "STELLAR":
-        case "SOLANA": {
-          keygenRes = yield __privateGet(this, _paraCoreInterface).platformUtils.ed25519Keygen(
-            __privateGet(this, _paraCoreInterface).ctx,
-            __privateGet(this, _authService).userId,
-            __privateGet(this, _paraCoreInterface).retrieveSessionCookie(),
-            __privateGet(this, _paraCoreInterface).getBackupKitEmailProps(),
-            walletType
-          );
-          break;
-        }
-        default: {
-          keygenRes = yield __privateGet(this, _paraCoreInterface).platformUtils.keygen(
-            __privateGet(this, _paraCoreInterface).ctx,
-            __privateGet(this, _authService).userId,
-            walletType,
-            null,
-            __privateGet(this, _paraCoreInterface).retrieveSessionCookie(),
-            __privateGet(this, _paraCoreInterface).getBackupKitEmailProps()
-          );
-          break;
+      const keygenRes = yield wrapWithSpan(
+        "mpc.keygen",
+        () => __async(this, null, function* () {
+          switch (walletType) {
+            case "STELLAR":
+            case "SOLANA":
+              return __privateGet(this, _paraCoreInterface).platformUtils.ed25519Keygen(
+                __privateGet(this, _paraCoreInterface).ctx,
+                __privateGet(this, _authService).userId,
+                __privateGet(this, _paraCoreInterface).retrieveSessionCookie(),
+                __privateGet(this, _paraCoreInterface).getBackupKitEmailProps(),
+                walletType
+              );
+            default:
+              return __privateGet(this, _paraCoreInterface).platformUtils.keygen(
+                __privateGet(this, _paraCoreInterface).ctx,
+                __privateGet(this, _authService).userId,
+                walletType,
+                null,
+                __privateGet(this, _paraCoreInterface).retrieveSessionCookie(),
+                __privateGet(this, _paraCoreInterface).getBackupKitEmailProps()
+              );
+          }
+        }),
+        {
+          "wallet.type": walletType,
+          "wallet.scheme": walletType === "SOLANA" || walletType === "STELLAR" ? "ED25519" : "DKLS"
         }
-      }
+      );
       const walletId = keygenRes.walletId;
       const walletScheme = walletType === "SOLANA" || walletType === "STELLAR" ? "ED25519" : "DKLS";
       signer = keygenRes.signer;
@@ -388,11 +398,16 @@ class WalletService {
       }
       return type;
     });
+    // wallets.fetch names the post-keygen wallet list reads (the polling-style
+    // GETs that follow each MPC keygen). The auto-instrumented HTTP child carries
+    // the URL and status so this stays cheap.
     this.fetchWallets = () => __async(this, null, function* () {
-      const res = yield __privateGet(this, _paraCoreInterface).isPortal() || __privateGet(this, _paraCoreInterface).isParaConnect() ? __privateGet(this, _paraCoreInterface).ctx.client.getAllWallets(__privateGet(this, _authService).userId) : __privateGet(this, _paraCoreInterface).ctx.client.getWallets(__privateGet(this, _authService).userId, true);
-      return res.data.wallets.filter(
-        (wallet) => !!wallet.address && wallet.sharesPersisted && (__privateGet(this, _paraCoreInterface).isParaConnect() || !__privateGet(this, _paraCoreInterface).isParaConnect() && this.isWalletSupported(entityToWallet(wallet)))
-      );
+      return wrapWithSpan("wallets.fetch", () => __async(this, null, function* () {
+        const res = yield __privateGet(this, _paraCoreInterface).isPortal() || __privateGet(this, _paraCoreInterface).isParaConnect() ? __privateGet(this, _paraCoreInterface).ctx.client.getAllWallets(__privateGet(this, _authService).userId) : __privateGet(this, _paraCoreInterface).ctx.client.getWallets(__privateGet(this, _authService).userId, true);
+        return res.data.wallets.filter(
+          (wallet) => !!wallet.address && wallet.sharesPersisted && (__privateGet(this, _paraCoreInterface).isParaConnect() || !__privateGet(this, _paraCoreInterface).isParaConnect() && this.isWalletSupported(entityToWallet(wallet)))
+        );
+      }));
     });
     this.getWalletBalance = (_0) => __async(this, [_0], function* ({ walletId, rpcUrl }) {
       return (yield __privateGet(this, _paraCoreInterface).ctx.client.getWalletBalance({ walletId, rpcUrl })).balance;