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

package/dist/cjs/constants.js

@@ -46,7 +46,7 @@ __export(constants_exports, {
   TRANSACTION_REVIEW_TIMEOUT_MS: () => TRANSACTION_REVIEW_TIMEOUT_MS
 });
 module.exports = __toCommonJS(constants_exports);
-const PARA_CORE_VERSION = "3.0.0-alpha.1";
+const PARA_CORE_VERSION = "3.0.0";
 const PREFIX = "@CAPSULE/";
 const PARA_PREFIX = "@PARA/";
 const LOCAL_STORAGE_AUTH_INFO = `${PREFIX}authInfo`;

package/dist/cjs/cryptography/utils.js

@@ -71,6 +71,7 @@ module.exports = __toCommonJS(utils_exports);
 var import_base64url = __toESM(require("base64url"));
 var import_node_forge = __toESM(require("node-forge"));
 var import_utils = require("../utils/index.js");
+var import_tracer = require("../telemetry/tracer.js");
 const rsa = import_node_forge.default.pki.rsa;
 const RSA_ENCRYPTION_SCHEME = "RSA-OAEP";
 const CONSTANT_IV = "794241bc819a125a7b78ea313decc0bc";
@@ -160,8 +161,10 @@ function getAsymmetricKeyPair(ctx, seedValue) {
     if (!ctx.disableWorkers) {
       options.workLoad = 100;
       options.workers = seedValue ? 1 : -1;
-      const workerRes = yield fetch(`${(0, import_utils.getPortalBaseURL)(ctx)}/static/js/prime.worker.min.js`);
-      const workerBlob = new Blob([yield workerRes.text()], { type: "application/javascript" });
+      const workerBlob = yield (0, import_tracer.wrapWithSpan)("worker.load_prime", () => __async(this, null, function* () {
+        const workerRes = yield fetch(`${(0, import_utils.getPortalBaseURL)(ctx)}/static/js/prime.worker.min.js`);
+        return new Blob([yield workerRes.text()], { type: "application/javascript" });
+      }));
       options.workerScript = URL.createObjectURL(workerBlob);
     }
     return new Promise(

package/dist/cjs/errors.js

@@ -17,6 +17,7 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var errors_exports = {};
 __export(errors_exports, {
+  PartnerConfigError: () => PartnerConfigError,
   TransactionReviewDenied: () => TransactionReviewDenied,
   TransactionReviewError: () => TransactionReviewError,
   TransactionReviewTimeout: () => TransactionReviewTimeout
@@ -43,8 +44,17 @@ class TransactionReviewTimeout extends Error {
     this.pendingTransactionId = pendingTransactionId;
   }
 }
+class PartnerConfigError extends Error {
+  constructor(code, message, detail) {
+    super(message);
+    this.name = "PartnerConfigError";
+    this.code = code;
+    this.detail = detail;
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  PartnerConfigError,
   TransactionReviewDenied,
   TransactionReviewError,
   TransactionReviewTimeout

package/dist/cjs/external/userManagementClient.js

@@ -35,10 +35,24 @@ __export(userManagementClient_exports, {
 module.exports = __toCommonJS(userManagementClient_exports);
 var import_user_management_client = __toESM(require("@getpara/user-management-client"));
 var import_types = require("../types/index.js");
+function getDevApiBaseUrlOverride(scheme = "http") {
+  const override = typeof globalThis !== "undefined" ? globalThis.__PARA_API_BASE_URL_OVERRIDE__ : void 0;
+  if (!override || typeof override !== "string") {
+    return void 0;
+  }
+  const url = new URL(override);
+  if (scheme === "ws") {
+    url.protocol = url.protocol === "https:" || url.protocol === "wss:" ? "wss:" : "ws:";
+  } else {
+    url.protocol = url.protocol === "wss:" || url.protocol === "https:" ? "https:" : "http:";
+  }
+  return url.toString();
+}
 function getBaseOAuthUrl(env) {
+  var _a;
   switch (env) {
     case import_types.Environment.DEV:
-      return "http://localhost:8080/";
+      return (_a = getDevApiBaseUrlOverride()) != null ? _a : "http://localhost:8080/";
     case import_types.Environment.SANDBOX:
       return "https://api.sandbox.usecapsule.com/";
     case import_types.Environment.BETA:
@@ -50,9 +64,10 @@ function getBaseOAuthUrl(env) {
   }
 }
 function getBaseUrl(env, scheme = "http") {
+  var _a;
   switch (env) {
     case import_types.Environment.DEV:
-      return `${scheme}://localhost:8080/`;
+      return (_a = getDevApiBaseUrlOverride(scheme)) != null ? _a : `${scheme}://localhost:8080/`;
     case import_types.Environment.SANDBOX:
       return `${scheme}s://api.sandbox.getpara.com/`;
     case import_types.Environment.BETA:
@@ -85,7 +100,8 @@ function initClient({
   partnerId,
   useFetchAdapter = false,
   retrieveSessionCookie,
-  persistSessionCookie
+  persistSessionCookie,
+  staticTraceContext
 }) {
   return new import_user_management_client.default({
     userManagementHost: getBaseUrl(env),
@@ -94,7 +110,8 @@ function initClient({
     partnerId,
     opts: { useFetchAdapter },
     retrieveSessionCookie,
-    persistSessionCookie
+    persistSessionCookie,
+    staticTraceContext
   });
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/cjs/index.js

@@ -29,9 +29,12 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   AccountLinkError: () => import_types.AccountLinkError,
+  AuthLayout: () => import_user_management_client.AuthLayout,
   AuthMethod: () => import_user_management_client.AuthMethod,
   AuthMethodStatus: () => import_user_management_client.AuthMethodStatus,
   COSMOS_WALLETS: () => import_user_management_client.COSMOS_WALLETS,
+  DeliveryChannel: () => import_user_management_client.DeliveryChannel,
+  ENCODED_CONFIG_VERSION: () => import_configEncoding.ENCODED_CONFIG_VERSION,
   EVM_WALLETS: () => import_user_management_client.EVM_WALLETS,
   EXTERNAL_WALLET_TYPES: () => import_user_management_client.EXTERNAL_WALLET_TYPES,
   EmailTheme: () => import_user_management_client.EmailTheme,
@@ -55,6 +58,7 @@ __export(src_exports, {
   RecoveryStatus: () => import_user_management_client.RecoveryStatus,
   SOLANA_WALLETS: () => import_user_management_client.SOLANA_WALLETS,
   STORAGE_PREFIX: () => import_constants.PREFIX,
+  SpanStatusCode: () => import_tracer.SpanStatusCode,
   ThemeMode: () => import_user_management_client.ThemeMode,
   WALLET_SCHEMES: () => import_user_management_client.WALLET_SCHEMES,
   WALLET_TYPES: () => import_user_management_client.WALLET_TYPES,
@@ -69,36 +73,61 @@ __export(src_exports, {
   default: () => src_default,
   dispatchEvent: () => import_utils.dispatchEvent,
   distributeNewShare: () => import_shareDistribution.distributeNewShare,
+  encodeConfigParams: () => import_configEncoding.encodeConfigParams,
   encodePrivateKeyToPemHex: () => import_utils2.encodePrivateKeyToPemHex,
   encryptPrivateKey: () => import_utils2.encryptPrivateKey,
   encryptPrivateKeyWithPassword: () => import_utils2.encryptPrivateKeyWithPassword,
   encryptWithDerivedPublicKey: () => import_utils2.encryptWithDerivedPublicKey,
+  endModalSession: () => import_modalSession.endModalSession,
   entityToWallet: () => import_utils.entityToWallet,
+  extractTraceContextFromUrl: () => import_tracer.extractTraceContextFromUrl,
+  flushTelemetry: () => import_init.flushTelemetry,
   formatAssetQuantity: () => import_user_management_client.formatAssetQuantity,
   formatCurrency: () => import_user_management_client.formatCurrency,
   getAsymmetricKeyPair: () => import_utils2.getAsymmetricKeyPair,
   getBaseUrl: () => import_userManagementClient.getBaseUrl,
+  getDefaultParentContext: () => import_tracer.getDefaultParentContext,
   getDerivedPrivateKeyAndDecrypt: () => import_utils2.getDerivedPrivateKeyAndDecrypt,
+  getModalSessionContext: () => import_modalSession.getModalSessionContext,
   getNetworkPrefix: () => import_onRamps.getNetworkPrefix,
   getOnRampAssets: () => import_onRamps.getOnRampAssets,
   getOnRampNetworks: () => import_onRamps.getOnRampNetworks,
+  getOrCreateSessionId: () => import_session.getOrCreateSessionId,
+  getParaConnectBaseUrl: () => import_url.getParaConnectBaseUrl,
   getPortalBaseURL: () => import_url.getPortalBaseURL,
   getPortalDomain: () => import_utils.getPortalDomain,
   getPublicKeyFromSignature: () => import_utils2.getPublicKeyFromSignature,
   getPublicKeyHex: () => import_utils2.getPublicKeyHex,
   getSHA256HashHex: () => import_utils2.getSHA256HashHex,
+  getTracer: () => import_tracer.getTracer,
+  getUrlTraceCarrier: () => import_tracer.getUrlTraceCarrier,
+  getUxState: () => import_uxState.getUxState,
   hashPasswordWithSalt: () => import_utils2.hashPasswordWithSalt,
   initClient: () => import_userManagementClient.initClient,
+  initTelemetry: () => import_init.initTelemetry,
+  isCompressionStreamSupported: () => import_configEncoding.isCompressionStreamSupported,
   isPortal: () => import_utils.isPortal,
+  isTelemetryInitialized: () => import_init.isTelemetryInitialized,
   isWalletSupported: () => import_wallet.isWalletSupported,
   mpcComputationClient: () => mpcComputationClient,
   offParaEvent: () => import_utils.offParaEvent,
   onParaEvent: () => import_utils.onParaEvent,
+  onTelemetryReady: () => import_init.onTelemetryReady,
   paraVersion: () => paraVersion,
   publicKeyFromHex: () => import_utils2.publicKeyFromHex,
+  recordActionOnSpan: () => import_uxAction.recordActionOnSpan,
+  setCurrentUserId: () => import_uxStateSpanProcessor.setCurrentUserId,
+  setCurrentView: () => import_uxState.setCurrentView,
+  setDefaultParentContext: () => import_tracer.setDefaultParentContext,
+  setLastInteraction: () => import_uxState.setLastInteraction,
   shortenUrl: () => import_utils.shortenUrl,
+  startModalSession: () => import_modalSession.startModalSession,
   toAssetInfoArray: () => import_onRamps.toAssetInfoArray,
-  transmissionUtilsRetrieve: () => import_transmissionUtils.retrieve
+  transmissionUtilsRetrieve: () => import_transmissionUtils.retrieve,
+  tryDecodeConfig: () => import_configEncoding.tryDecodeConfig,
+  warnOnce: () => import_utils.warnOnce,
+  wrapWithSpan: () => import_tracer.wrapWithSpan,
+  wrapWithSpanInContext: () => import_tracer.wrapWithSpanInContext
 });
 module.exports = __toCommonJS(src_exports);
 var import_ParaCore = require("./ParaCore.js");
@@ -124,15 +153,26 @@ __reExport(src_exports, require("./utils/config.js"), module.exports);
 var import_wallet = require("./utils/wallet.js");
 var import_onRamps = require("./utils/onRamps.js");
 var import_url = require("./utils/url.js");
+var import_configEncoding = require("./utils/configEncoding.js");
 var import_transmissionUtils = require("./transmission/transmissionUtils.js");
+var import_tracer = require("./telemetry/tracer.js");
+var import_session = require("./telemetry/session.js");
+var import_init = require("./telemetry/init.js");
+var import_uxState = require("./telemetry/uxState.js");
+var import_uxStateSpanProcessor = require("./telemetry/uxStateSpanProcessor.js");
+var import_uxAction = require("./telemetry/uxAction.js");
+var import_modalSession = require("./telemetry/modalSession.js");
 const paraVersion = import_ParaCore.ParaCore.version;
 var src_default = import_ParaCore.ParaCore;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AccountLinkError,
+  AuthLayout,
   AuthMethod,
   AuthMethodStatus,
   COSMOS_WALLETS,
+  DeliveryChannel,
+  ENCODED_CONFIG_VERSION,
   EVM_WALLETS,
   EXTERNAL_WALLET_TYPES,
   EmailTheme,
@@ -156,6 +196,7 @@ var src_default = import_ParaCore.ParaCore;
   RecoveryStatus,
   SOLANA_WALLETS,
   STORAGE_PREFIX,
+  SpanStatusCode,
   ThemeMode,
   WALLET_SCHEMES,
   WALLET_TYPES,
@@ -169,36 +210,61 @@ var src_default = import_ParaCore.ParaCore;
   decryptWithPrivateKey,
   dispatchEvent,
   distributeNewShare,
+  encodeConfigParams,
   encodePrivateKeyToPemHex,
   encryptPrivateKey,
   encryptPrivateKeyWithPassword,
   encryptWithDerivedPublicKey,
+  endModalSession,
   entityToWallet,
+  extractTraceContextFromUrl,
+  flushTelemetry,
   formatAssetQuantity,
   formatCurrency,
   getAsymmetricKeyPair,
   getBaseUrl,
+  getDefaultParentContext,
   getDerivedPrivateKeyAndDecrypt,
+  getModalSessionContext,
   getNetworkPrefix,
   getOnRampAssets,
   getOnRampNetworks,
+  getOrCreateSessionId,
+  getParaConnectBaseUrl,
   getPortalBaseURL,
   getPortalDomain,
   getPublicKeyFromSignature,
   getPublicKeyHex,
   getSHA256HashHex,
+  getTracer,
+  getUrlTraceCarrier,
+  getUxState,
   hashPasswordWithSalt,
   initClient,
+  initTelemetry,
+  isCompressionStreamSupported,
   isPortal,
+  isTelemetryInitialized,
   isWalletSupported,
   mpcComputationClient,
   offParaEvent,
   onParaEvent,
+  onTelemetryReady,
   paraVersion,
   publicKeyFromHex,
+  recordActionOnSpan,
+  setCurrentUserId,
+  setCurrentView,
+  setDefaultParentContext,
+  setLastInteraction,
   shortenUrl,
+  startModalSession,
   toAssetInfoArray,
   transmissionUtilsRetrieve,
+  tryDecodeConfig,
+  warnOnce,
+  wrapWithSpan,
+  wrapWithSpanInContext,
   ...require("./types/smartAccounts.js"),
   ...require("./types/coreApi.js"),
   ...require("./types/events.js"),

package/dist/cjs/services/AuthService.js

@@ -91,6 +91,8 @@ var constants = __toESM(require("../constants.js"));
 var import_LoginFlowService = require("./LoginFlowService.js");
 var import_VerificationFlowService = require("./VerificationFlowService.js");
 var import_SignupFlowService = require("./SignupFlowService.js");
+var import_tracer = require("../telemetry/tracer.js");
+var import_uxStateSpanProcessor = require("../telemetry/uxStateSpanProcessor.js");
 var import_stateListener = require("../utils/stateListener.js");
 var _stateManager, _loginFlowService, _signupFlowService, _verificationFlowService, _externalWalletService, _pregenWalletService, _sessionManagementService, _portalUrlService, _paraCoreInterface, _authInfo, _isEnclaveUser;
 class AuthService {
@@ -142,12 +144,14 @@ class AuthService {
       }));
     };
     this.prepareLogin = () => __async(this, null, function* () {
-      yield __privateGet(this, _paraCoreInterface).logout({ skipStateReset: true });
-      const { sessionLookupId } = yield __privateGet(this, _sessionManagementService).touchSession(true);
-      if (!__privateGet(this, _paraCoreInterface).loginEncryptionKeyPair) {
-        yield __privateGet(this, _paraCoreInterface).setLoginEncryptionKeyPair();
-      }
-      return sessionLookupId;
+      return (0, import_tracer.wrapWithSpan)("auth.prepare_login", () => __async(this, null, function* () {
+        yield __privateGet(this, _paraCoreInterface).logout({ skipStateReset: true });
+        const { sessionLookupId } = yield __privateGet(this, _sessionManagementService).touchSession(true);
+        if (!__privateGet(this, _paraCoreInterface).loginEncryptionKeyPair) {
+          yield __privateGet(this, _paraCoreInterface).setLoginEncryptionKeyPair();
+        }
+        return sessionLookupId;
+      }));
     });
     this.setAuth = (_0, ..._1) => __async(this, [_0, ..._1], function* (auth, { extras = {}, userId } = {}) {
       const authInfo = __spreadValues(__spreadValues({}, (0, import_user_management_client.extractAuthInfo)(auth, { isRequired: true })), extras || {});
@@ -168,6 +172,7 @@ class AuthService {
     });
     this.setUserId = (userId) => __async(this, null, function* () {
       this.userId = userId;
+      (0, import_uxStateSpanProcessor.setCurrentUserId)(userId);
       yield __privateGet(this, _paraCoreInterface).localStorageSetItem(constants.LOCAL_STORAGE_USER_ID, userId);
     });
     this.assertIsAuthSet = (allowed) => {
@@ -243,9 +248,14 @@ class AuthService {
       });
     });
     this.performSignUpOrLogIn = (params) => __async(this, null, function* () {
+      var _b;
       const _a = params, { auth } = _a, urlOptions = __objRest(_a, ["auth"]);
       try {
-        const serverAuthState = yield __privateGet(this, _paraCoreInterface).ctx.client.signUpOrLogIn(__spreadValues(__spreadValues({}, auth), __privateGet(this, _paraCoreInterface).getVerificationEmailProps()));
+        const serverAuthState = yield (0, import_tracer.wrapWithSpan)(
+          "auth.send_otp",
+          () => __privateGet(this, _paraCoreInterface).ctx.client.signUpOrLogIn(__spreadValues(__spreadValues({}, auth), __privateGet(this, _paraCoreInterface).getVerificationEmailProps())),
+          { "auth.method": (_b = auth.authType) != null ? _b : "unknown" }
+        );
         return { authState: serverAuthState, opts: urlOptions };
       } catch (error) {
         if (error.message.includes("max beta users reached")) {
@@ -526,51 +536,59 @@ class AuthService {
           break;
         }
       }
-      yield (0, import_stateListener.waitForAuthStateChange)({
-        stateManager: __privateGet(this, _stateManager),
-        resolvePhases: [
-          // awaiting_session_start will be hit for non-SLO logins & all SLO logins/sign ups
-          { phase: "awaiting_session_start", onPhase: () => void 0 }
-        ],
-        rejectPhases: [
-          {
-            phase: "unauthenticated",
-            onPhase: () => new Error("OAuth canceled")
-          }
-        ]
-      });
+      yield (0, import_tracer.wrapWithSpan)(
+        "oauth.redirect_wait",
+        () => (0, import_stateListener.waitForAuthStateChange)({
+          stateManager: __privateGet(this, _stateManager),
+          resolvePhases: [
+            // awaiting_session_start will be hit for non-SLO logins & all SLO logins/sign ups
+            { phase: "awaiting_session_start", onPhase: () => void 0 }
+          ],
+          rejectPhases: [
+            {
+              phase: "unauthenticated",
+              onPhase: () => new Error("OAuth canceled")
+            }
+          ]
+        }),
+        { "auth.method": params.method }
+      );
       __privateGet(this, _stateManager).send({
         type: "WAIT_FOR_SESSION",
         data: __spreadProps(__spreadValues({}, params.sessionPollingCallbacks), { autoCreateWallets: true })
       });
-      const resp = yield (0, import_stateListener.waitForAuthStateChange)({
-        stateManager: __privateGet(this, _stateManager),
-        resolvePhases: [
-          {
-            phase: "authenticated",
-            onPhase: (state) => {
-              const createdWallets = state.newWalletsResult;
-              if (createdWallets) {
+      const resp = yield (0, import_tracer.wrapWithSpan)(
+        "oauth.session_wait",
+        () => (0, import_stateListener.waitForAuthStateChange)({
+          stateManager: __privateGet(this, _stateManager),
+          resolvePhases: [
+            {
+              phase: "authenticated",
+              onPhase: (state) => {
+                const createdWallets = state.newWalletsResult;
+                if (createdWallets) {
+                  return {
+                    hasCreatedWallets: true,
+                    recoverySecret: state.newWalletsResult.recoverySecret
+                  };
+                }
                 return {
-                  hasCreatedWallets: true,
-                  recoverySecret: state.newWalletsResult.recoverySecret
+                  hasCreatedWallets: false,
+                  recoverySecret: void 0
                 };
               }
-              return {
-                hasCreatedWallets: false,
-                recoverySecret: void 0
-              };
             }
-          }
-        ],
-        rejectPhases: [
-          {
-            phase: "unauthenticated",
-            onPhase: () => new Error("Session waiting canceled")
-          }
-        ],
-        waitForCoreAuthenticated: true
-      });
+          ],
+          rejectPhases: [
+            {
+              phase: "unauthenticated",
+              onPhase: () => new Error("Session waiting canceled")
+            }
+          ],
+          waitForCoreAuthenticated: true
+        }),
+        { "auth.method": params.method }
+      );
       return __spreadValues({ authInfo: this.authInfo }, resp);
     });
     this.performVerifyTelegram = (params) => __async(this, null, function* () {
@@ -687,7 +705,7 @@ class AuthService {
       const { url } = yield this.getNewCredentialAndUrl({ isForNewDevice: true, authMethod });
       return url;
     });
-    this.resendVerificationCode = (_0) => __async(this, [_0], function* ({ type: reason = "SIGNUP" }) {
+    this.resendVerificationCode = (_0) => __async(this, [_0], function* ({ type: reason = "SIGNUP", deliveryChannel }) {
       let type, linkedAccountId;
       switch (reason) {
         case "SIGNUP":
@@ -709,10 +727,11 @@ class AuthService {
       if (type !== "EMAIL" && type !== "PHONE") {
         throw new Error("invalid auth type for verification code");
       }
-      yield __privateGet(this, _paraCoreInterface).ctx.client.resendVerificationCode(__spreadValues({
+      return yield __privateGet(this, _paraCoreInterface).ctx.client.resendVerificationCode(__spreadValues({
         userId,
         type,
-        linkedAccountId
+        linkedAccountId,
+        deliveryChannel
       }, __privateGet(this, _paraCoreInterface).getVerificationEmailProps()));
     });
     __privateSet(this, _paraCoreInterface, paraCore.getAuthServiceInterface());

package/dist/cjs/services/LoginFlowService.js

@@ -75,6 +75,7 @@ var import_utils = require("../cryptography/utils.js");
 var import_events = require("../types/events.js");
 var import_utils2 = require("../utils/index.js");
 var import_stateListener = require("../utils/stateListener.js");
+var import_tracer = require("../telemetry/tracer.js");
 class LoginFlowService extends import_BaseAuthFlowService.BaseAuthFlowService {
   constructor() {
     super(...arguments);
@@ -136,35 +137,37 @@ class LoginFlowService extends import_BaseAuthFlowService.BaseAuthFlowService {
       return result;
     });
     this.waitForLogin = (params) => __async(this, null, function* () {
-      this.stateManager.send({
-        type: "WAIT_FOR_SESSION",
-        data: __spreadValues({}, params)
-      });
-      return yield (0, import_stateListener.waitForAuthStateChange)({
-        stateManager: this.stateManager,
-        resolvePhases: [
-          {
-            phase: "authenticated",
-            onPhase: () => {
-              const needsWallet = this.stateManager.getSnapshot().needsWallet;
-              (0, import_utils2.dispatchEvent)(import_events.ParaEvent.LOGIN_EVENT, true);
-              return {
-                partnerId: this.paraCoreInterface.partnerId,
-                needsWallet: needsWallet || Object.values(this.services.walletService.wallets).length === 0
-              };
+      return (0, import_tracer.wrapWithSpan)("auth.login_wait", () => __async(this, null, function* () {
+        this.stateManager.send({
+          type: "WAIT_FOR_SESSION",
+          data: __spreadValues({}, params)
+        });
+        return yield (0, import_stateListener.waitForAuthStateChange)({
+          stateManager: this.stateManager,
+          resolvePhases: [
+            {
+              phase: "authenticated",
+              onPhase: () => {
+                const needsWallet = this.stateManager.getSnapshot().needsWallet;
+                (0, import_utils2.dispatchEvent)(import_events.ParaEvent.LOGIN_EVENT, true);
+                return {
+                  partnerId: this.paraCoreInterface.partnerId,
+                  needsWallet: needsWallet || Object.values(this.services.walletService.wallets).length === 0
+                };
+              }
             }
+          ],
+          rejectPhases: [
+            {
+              phase: "unauthenticated",
+              onPhase: () => new Error("canceled")
+            }
+          ],
+          onReject: () => {
+            (0, import_utils2.dispatchEvent)(import_events.ParaEvent.LOGIN_EVENT, { isComplete: false }, "failed to setup user");
           }
-        ],
-        rejectPhases: [
-          {
-            phase: "unauthenticated",
-            onPhase: () => new Error("canceled")
-          }
-        ],
-        onReject: () => {
-          (0, import_utils2.dispatchEvent)(import_events.ParaEvent.LOGIN_EVENT, { isComplete: false }, "failed to setup user");
-        }
-      });
+        });
+      }));
     });
   }
 }