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

package/dist/esm/constants.js

@@ -1,5 +1,5 @@
 import "./chunk-7B52C2XE.js";
-const PARA_CORE_VERSION = "3.0.0-alpha.1";
+const PARA_CORE_VERSION = "3.1.0";
 const PREFIX = "@CAPSULE/";
 const PARA_PREFIX = "@PARA/";
 const LOCAL_STORAGE_AUTH_INFO = `${PREFIX}authInfo`;

package/dist/esm/cryptography/utils.js

@@ -4,6 +4,7 @@ import {
 import base64url from "base64url";
 import forge from "node-forge";
 import { getPortalBaseURL } from "../utils/index.js";
+import { wrapWithSpan } from "../telemetry/tracer.js";
 const rsa = forge.pki.rsa;
 const RSA_ENCRYPTION_SCHEME = "RSA-OAEP";
 const CONSTANT_IV = "794241bc819a125a7b78ea313decc0bc";
@@ -93,8 +94,10 @@ function getAsymmetricKeyPair(ctx, seedValue) {
     if (!ctx.disableWorkers) {
       options.workLoad = 100;
       options.workers = seedValue ? 1 : -1;
-      const workerRes = yield fetch(`${getPortalBaseURL(ctx)}/static/js/prime.worker.min.js`);
-      const workerBlob = new Blob([yield workerRes.text()], { type: "application/javascript" });
+      const workerBlob = yield wrapWithSpan("worker.load_prime", () => __async(this, null, function* () {
+        const workerRes = yield fetch(`${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/esm/errors.js

@@ -20,7 +20,16 @@ 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;
+  }
+}
 export {
+  PartnerConfigError,
   TransactionReviewDenied,
   TransactionReviewError,
   TransactionReviewTimeout

package/dist/esm/external/userManagementClient.js

@@ -1,10 +1,24 @@
 import "../chunk-7B52C2XE.js";
 import Client from "@getpara/user-management-client";
 import { Environment } from "../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 Environment.DEV:
-      return "http://localhost:8080/";
+      return (_a = getDevApiBaseUrlOverride()) != null ? _a : "http://localhost:8080/";
     case Environment.SANDBOX:
       return "https://api.sandbox.usecapsule.com/";
     case Environment.BETA:
@@ -16,9 +30,10 @@ function getBaseOAuthUrl(env) {
   }
 }
 function getBaseUrl(env, scheme = "http") {
+  var _a;
   switch (env) {
     case Environment.DEV:
-      return `${scheme}://localhost:8080/`;
+      return (_a = getDevApiBaseUrlOverride(scheme)) != null ? _a : `${scheme}://localhost:8080/`;
     case Environment.SANDBOX:
       return `${scheme}s://api.sandbox.getpara.com/`;
     case Environment.BETA:
@@ -51,7 +66,8 @@ function initClient({
   partnerId,
   useFetchAdapter = false,
   retrieveSessionCookie,
-  persistSessionCookie
+  persistSessionCookie,
+  staticTraceContext
 }) {
   return new Client({
     userManagementHost: getBaseUrl(env),
@@ -60,7 +76,8 @@ function initClient({
     partnerId,
     opts: { useFetchAdapter },
     retrieveSessionCookie,
-    persistSessionCookie
+    persistSessionCookie,
+    staticTraceContext
   });
 }
 export {

package/dist/esm/index.js

@@ -3,6 +3,7 @@ import { ParaCore } from "./ParaCore.js";
 import {
   AuthMethod,
   AuthMethodStatus,
+  AuthLayout,
   EmailTheme,
   Network,
   WalletType,
@@ -26,7 +27,8 @@ import {
   SOLANA_WALLETS,
   COSMOS_WALLETS,
   formatAssetQuantity,
-  formatCurrency
+  formatCurrency,
+  DeliveryChannel
 } from "@getpara/user-management-client";
 import {
   PopupType,
@@ -45,7 +47,8 @@ import {
   entityToWallet,
   constructUrl,
   shortenUrl,
-  isPortal
+  isPortal,
+  warnOnce
 } from "./utils/index.js";
 import {
   PREFIX,
@@ -83,15 +86,40 @@ export * from "./utils/phone.js";
 export * from "./utils/config.js";
 import { isWalletSupported } from "./utils/wallet.js";
 import { getNetworkPrefix, getOnRampAssets, getOnRampNetworks, toAssetInfoArray } from "./utils/onRamps.js";
-import { getPortalBaseURL } from "./utils/url.js";
+import { getPortalBaseURL, getParaConnectBaseUrl } from "./utils/url.js";
+import {
+  encodeConfigParams,
+  tryDecodeConfig,
+  isCompressionStreamSupported,
+  ENCODED_CONFIG_VERSION
+} from "./utils/configEncoding.js";
 import { retrieve } from "./transmission/transmissionUtils.js";
+import {
+  getTracer,
+  wrapWithSpan,
+  wrapWithSpanInContext,
+  extractTraceContextFromUrl,
+  getUrlTraceCarrier,
+  setDefaultParentContext,
+  getDefaultParentContext,
+  SpanStatusCode
+} from "./telemetry/tracer.js";
+import { getOrCreateSessionId } from "./telemetry/session.js";
+import { initTelemetry, isTelemetryInitialized, onTelemetryReady, flushTelemetry } from "./telemetry/init.js";
+import { getUxState, setCurrentView, setLastInteraction } from "./telemetry/uxState.js";
+import { setCurrentUserId } from "./telemetry/uxStateSpanProcessor.js";
+import { recordActionOnSpan } from "./telemetry/uxAction.js";
+import { startModalSession, endModalSession, getModalSessionContext } from "./telemetry/modalSession.js";
 const paraVersion = ParaCore.version;
 var src_default = ParaCore;
 export {
   AccountLinkError,
+  AuthLayout,
   AuthMethod,
   AuthMethodStatus,
   COSMOS_WALLETS,
+  DeliveryChannel,
+  ENCODED_CONFIG_VERSION,
   EVM_WALLETS,
   EXTERNAL_WALLET_TYPES,
   EmailTheme,
@@ -115,6 +143,7 @@ export {
   RecoveryStatus,
   SOLANA_WALLETS,
   PREFIX as STORAGE_PREFIX,
+  SpanStatusCode,
   ThemeMode,
   WALLET_SCHEMES,
   WALLET_TYPES,
@@ -129,34 +158,59 @@ export {
   src_default as default,
   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,
-  retrieve as transmissionUtilsRetrieve
+  retrieve as transmissionUtilsRetrieve,
+  tryDecodeConfig,
+  warnOnce,
+  wrapWithSpan,
+  wrapWithSpanInContext
 };

package/dist/esm/services/AuthService.js

@@ -23,6 +23,8 @@ import * as constants from "../constants.js";
 import { LoginFlowService } from "./LoginFlowService.js";
 import { VerificationFlowService } from "./VerificationFlowService.js";
 import { SignupFlowService } from "./SignupFlowService.js";
+import { wrapWithSpan } from "../telemetry/tracer.js";
+import { setCurrentUserId } from "../telemetry/uxStateSpanProcessor.js";
 import { waitForAuthStateChange } from "../utils/stateListener.js";
 class AuthService {
   constructor(paraCore) {
@@ -73,12 +75,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 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({}, extractAuthInfo(auth, { isRequired: true })), extras || {});
@@ -99,6 +103,7 @@ class AuthService {
     });
     this.setUserId = (userId) => __async(this, null, function* () {
       this.userId = userId;
+      setCurrentUserId(userId);
       yield __privateGet(this, _paraCoreInterface).localStorageSetItem(constants.LOCAL_STORAGE_USER_ID, userId);
     });
     this.assertIsAuthSet = (allowed) => {
@@ -174,9 +179,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 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")) {
@@ -457,51 +467,59 @@ class AuthService {
           break;
         }
       }
-      yield 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 wrapWithSpan(
+        "oauth.redirect_wait",
+        () => 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 waitForAuthStateChange({
-        stateManager: __privateGet(this, _stateManager),
-        resolvePhases: [
-          {
-            phase: "authenticated",
-            onPhase: (state) => {
-              const createdWallets = state.newWalletsResult;
-              if (createdWallets) {
+      const resp = yield wrapWithSpan(
+        "oauth.session_wait",
+        () => 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* () {
@@ -618,7 +636,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":
@@ -640,10 +658,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/esm/services/LoginFlowService.js

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