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

package/dist/cjs/services/PregenWalletService.js

@@ -70,8 +70,9 @@ var import_utils = require("../utils/index.js");
 var import_events = require("../types/events.js");
 var import_shareDistribution = require("../shares/shareDistribution.js");
 var import_constants = require("../constants.js");
+var import_tracer = require("../telemetry/tracer.js");
 var import_stateListener = require("../utils/stateListener.js");
-var _stateManager, _authService, _walletService, _pollingService, _paraCoreInterface, _isCreateGuestWalletsPending, _fetchOverridePromise;
+var _stateManager, _authService, _walletService, _pollingService, _paraCoreInterface, _isCreateGuestWalletsPending, _fetchOverridePromise, _claimPregenWalletEntities;
 class PregenWalletService {
   constructor(paraCore) {
     __privateAdd(this, _stateManager);
@@ -129,37 +130,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) => !!import_wallet2.WalletSchemeTypeMap[w.scheme][type]);
+          const wallet = claimed.find((w) => !!import_wallet2.WalletSchemeTypeMap[w.scheme][type]);
           if (!wallet) {
             return acc;
           }
@@ -173,48 +187,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 (0, import_shareDistribution.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 (0, import_tracer.wrapWithSpan)(
+            "mpc.claim",
+            () => (0, import_shareDistribution.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 (0, import_tracer.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;
           }
@@ -233,8 +275,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 ? (0, import_user_management_client.toPregenIds)(pregenId) : this.pregenIds;
       if (!pregenIds || Object.keys(pregenIds).length === 0) {
@@ -266,30 +308,36 @@ class PregenWalletService {
         _type != null ? _type : (_b = supportedWalletTypes.find(({ optional }) => !optional)) == null ? void 0 : _b.type
       );
       const [pregenIdentifierType, pregenIdentifier] = (0, import_user_management_client.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 (0, import_tracer.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,
@@ -438,6 +486,7 @@ _pollingService = new WeakMap();
 _paraCoreInterface = new WeakMap();
 _isCreateGuestWalletsPending = new WeakMap();
 _fetchOverridePromise = new WeakMap();
+_claimPregenWalletEntities = new WeakMap();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   PregenWalletService

package/dist/cjs/services/SessionManagementService.js

@@ -48,6 +48,7 @@ __export(SessionManagementService_exports, {
 });
 module.exports = __toCommonJS(SessionManagementService_exports);
 var import_wallet = require("../utils/wallet.js");
+var import_tracer = require("../telemetry/tracer.js");
 var _authService, _portalUrlService, _walletService, _pregenWalletService, _externalWalletService, _paraCoreInterface, _isImportedSession, _regeneratePromise, _handleTouchSessionError, _doTouchSession;
 class SessionManagementService {
   constructor(paraCore) {
@@ -96,14 +97,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 (0, import_tracer.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/cjs/services/SignupFlowService.js

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

package/dist/cjs/services/VerificationFlowService.js

@@ -70,6 +70,7 @@ var import_user_management_client = require("@getpara/user-management-client");
 var import_BaseAuthFlowService = require("./BaseAuthFlowService.js");
 var import_constants = require("../constants.js");
 var import_stateListener = require("../utils/stateListener.js");
+var import_tracer = require("../telemetry/tracer.js");
 class VerificationFlowService extends import_BaseAuthFlowService.BaseAuthFlowService {
   constructor() {
     super(...arguments);
@@ -101,16 +102,18 @@ class VerificationFlowService extends import_BaseAuthFlowService.BaseAuthFlowSer
       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 (0, import_tracer.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/cjs/services/WalletService.js

@@ -83,6 +83,7 @@ var import_events = require("../types/events.js");
 var import_constants = require("../constants.js");
 var import_shareDistribution = require("../shares/shareDistribution.js");
 var import_recovery = require("../shares/recovery.js");
+var import_tracer = require("../telemetry/tracer.js");
 var _authService, _pollingService, _pregenWalletService, _externalWalletService, _paraCoreInterface, _wallets, _currentWalletIds, _isWalletOwned, _getMissingTypes, _encodeWalletBase64;
 class WalletService {
   constructor(paraCore) {
@@ -164,15 +165,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({}, (0, import_wallet2.entityToWallet)(entity)), this.wallets[entity.id]);
-        }
-      });
-      yield this.setWallets(this.wallets);
+      return (0, import_tracer.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({}, (0, import_wallet2.entityToWallet)(entity)), this.wallets[entity.id]);
+          }
+        });
+        yield this.setWallets(this.wallets);
+      }));
     });
     this.addToCurrentWalletIds = (walletIds, options) => __async(this, null, function* () {
       const updatedWalletIds = __spreadValues({}, this.currentWalletIds);
@@ -212,31 +218,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 (0, import_tracer.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;
@@ -444,11 +454,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((0, import_wallet2.entityToWallet)(wallet)))
-      );
+      return (0, import_tracer.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((0, import_wallet2.entityToWallet)(wallet)))
+        );
+      }));
     });
     this.getWalletBalance = (_0) => __async(this, [_0], function* ({ walletId, rpcUrl }) {
       return (yield __privateGet(this, _paraCoreInterface).ctx.client.getWalletBalance({ walletId, rpcUrl })).balance;