@getpara/core-sdk 2.11.0 → 2.13.0

package/dist/esm/state/CoreStateManager.js

@@ -0,0 +1,261 @@
+import {
+  __spreadProps,
+  __spreadValues
+} from "../chunk-7B52C2XE.js";
+import { createActor } from "xstate";
+import { createCoreStateMachine } from "./machines/coreStateMachine.js";
+const _CoreStateManager = class _CoreStateManager {
+  constructor(paraCore) {
+    this.listeners = /* @__PURE__ */ new Set();
+    this.childSubscriptions = /* @__PURE__ */ new Map();
+    this.currentAuthRefId = null;
+    this.currentWalletRefId = null;
+    this.lastNotifiedState = null;
+    const stateMachineInterface = paraCore.getStateMachineInterface();
+    this.devLog = stateMachineInterface.devLog;
+    const machine = createCoreStateMachine(stateMachineInterface);
+    this.service = createActor(machine);
+    this.service.subscribe((state) => {
+      this.subscribeToChildMachines(state);
+      const coreState = this.mapXStateToCoreState(state);
+      this.notifyListeners(coreState);
+    });
+  }
+  subscribeToChildMachines(state) {
+    this.subscribeToChildRef(state.context.authMachineRef, "auth");
+    this.subscribeToChildRef(state.context.walletMachineRef, "wallet");
+  }
+  subscribeToChildRef(ref, slot) {
+    var _a, _b, _c;
+    const currentIdKey = slot === "auth" ? "currentAuthRefId" : "currentWalletRefId";
+    const currentId = this[currentIdKey];
+    if (((_a = ref == null ? void 0 : ref.id) != null ? _a : null) === currentId) return;
+    if (currentId) {
+      (_b = this.childSubscriptions.get(currentId)) == null ? void 0 : _b();
+      this.childSubscriptions.delete(currentId);
+    }
+    this[currentIdKey] = (_c = ref == null ? void 0 : ref.id) != null ? _c : null;
+    if (ref) {
+      const subscription = ref.subscribe(() => {
+        const coreState = this.mapXStateToCoreState(this.service.getSnapshot());
+        this.notifyListeners(coreState);
+      });
+      this.childSubscriptions.set(ref.id, () => subscription.unsubscribe());
+    }
+  }
+  start() {
+    this.service.start();
+  }
+  stop() {
+    this.childSubscriptions.forEach((unsubscribe) => unsubscribe());
+    this.childSubscriptions.clear();
+    this.currentAuthRefId = null;
+    this.currentWalletRefId = null;
+    this.lastNotifiedState = null;
+    this.service.stop();
+  }
+  send(event) {
+    this.service.send(event);
+  }
+  getSnapshot() {
+    return this.mapXStateToCoreState(this.service.getSnapshot());
+  }
+  onStateChange(listener) {
+    this.listeners.add(listener);
+    listener(this.getSnapshot());
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  getAuthMachineState(xstate) {
+    var _a, _b;
+    return (_b = (_a = xstate.context) == null ? void 0 : _a.authMachineRef) == null ? void 0 : _b.getSnapshot();
+  }
+  getWalletMachineState(xstate) {
+    var _a, _b;
+    return (_b = (_a = xstate.context) == null ? void 0 : _a.walletMachineRef) == null ? void 0 : _b.getSnapshot();
+  }
+  /**
+   * Computes AuthStateInfo from the auth machine context.
+   * Extracts all data needed by UI consumers from authStateResult.
+   */
+  computeAuthStateInfo(authContext, walletContext) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _A;
+    const defaultAuthStateInfo = {
+      userId: null,
+      isPasskeySupported: false,
+      passkeyHints: null,
+      hasPasskey: false,
+      hasPassword: false,
+      hasPin: false,
+      passkeyUrl: null,
+      passkeyKnownDeviceUrl: null,
+      passwordUrl: null,
+      pinUrl: null,
+      verificationUrl: null,
+      externalWalletVerification: null,
+      recoverySecret: null,
+      isNewUser: false
+    };
+    if (!authContext) {
+      return defaultAuthStateInfo;
+    }
+    const authStateResult = authContext.authStateResult;
+    const externalWalletVerification = authContext.externalWalletSignVerification;
+    const isNewUser = (_a = authContext.isNewUser) != null ? _a : false;
+    const recoverySecret = (_c = (_b = walletContext == null ? void 0 : walletContext.newWalletsResult) == null ? void 0 : _b.recoverySecret) != null ? _c : null;
+    if (!authStateResult) {
+      return __spreadProps(__spreadValues({}, defaultAuthStateInfo), {
+        isNewUser,
+        recoverySecret,
+        externalWalletVerification: externalWalletVerification ? {
+          signatureVerificationMessage: (_d = externalWalletVerification.signatureVerificationMessage) != null ? _d : "",
+          walletAddress: (_f = (_e = externalWalletVerification.externalWallet) == null ? void 0 : _e.address) != null ? _f : "",
+          walletType: (_h = (_g = externalWalletVerification.externalWallet) == null ? void 0 : _g.type) != null ? _h : ""
+        } : null
+      });
+    }
+    const stage = authStateResult.stage;
+    const userId = (_i = authStateResult.userId) != null ? _i : null;
+    let hasPasskey = false;
+    let hasPassword = false;
+    let hasPin = false;
+    let isPasskeySupported = false;
+    let passkeyUrl = null;
+    let passkeyKnownDeviceUrl = null;
+    let passwordUrl = null;
+    let pinUrl = null;
+    let verificationUrl = null;
+    let passkeyHints = null;
+    if (stage === "login") {
+      const loginState = authStateResult;
+      const authMethods = (_j = loginState.loginAuthMethods) != null ? _j : [];
+      hasPasskey = authMethods.includes("PASSKEY");
+      hasPassword = authMethods.includes("PASSWORD");
+      hasPin = authMethods.includes("PIN");
+      isPasskeySupported = (_k = loginState.isPasskeySupported) != null ? _k : false;
+      passkeyUrl = (_l = loginState.passkeyUrl) != null ? _l : null;
+      passkeyKnownDeviceUrl = (_m = loginState.passkeyKnownDeviceUrl) != null ? _m : null;
+      passwordUrl = (_n = loginState.passwordUrl) != null ? _n : null;
+      pinUrl = (_o = loginState.pinUrl) != null ? _o : null;
+      passkeyHints = (_p = loginState.biometricHints) != null ? _p : null;
+    } else if (stage === "signup") {
+      const signupState = authStateResult;
+      const authMethods = (_q = signupState.signupAuthMethods) != null ? _q : [];
+      hasPasskey = authMethods.includes("PASSKEY");
+      hasPassword = authMethods.includes("PASSWORD");
+      hasPin = authMethods.includes("PIN");
+      isPasskeySupported = (_r = signupState.isPasskeySupported) != null ? _r : false;
+      passkeyUrl = (_s = signupState.passkeyUrl) != null ? _s : null;
+      passwordUrl = (_t = signupState.passwordUrl) != null ? _t : null;
+      pinUrl = (_u = signupState.pinUrl) != null ? _u : null;
+    } else if (stage === "verify") {
+      const verifyState = authStateResult;
+      verificationUrl = (_v = verifyState.loginUrl) != null ? _v : null;
+    }
+    return {
+      userId,
+      isPasskeySupported,
+      passkeyHints,
+      hasPasskey,
+      hasPassword,
+      hasPin,
+      passkeyUrl,
+      passkeyKnownDeviceUrl,
+      passwordUrl,
+      pinUrl,
+      verificationUrl,
+      externalWalletVerification: externalWalletVerification ? {
+        signatureVerificationMessage: (_w = externalWalletVerification.signatureVerificationMessage) != null ? _w : "",
+        walletAddress: (_y = (_x = externalWalletVerification.externalWallet) == null ? void 0 : _x.address) != null ? _y : "",
+        walletType: (_A = (_z = externalWalletVerification.externalWallet) == null ? void 0 : _z.type) != null ? _A : ""
+      } : null,
+      recoverySecret,
+      isNewUser
+    };
+  }
+  mapXStateToCoreState(xstate) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    const coreStatePhase = xstate.value;
+    const authMachineState = this.getAuthMachineState(xstate);
+    const walletMachineState = this.getWalletMachineState(xstate);
+    const authStatePhase = (_a = authMachineState == null ? void 0 : authMachineState.value) != null ? _a : "uninitialized";
+    const walletStatePhase = (_b = walletMachineState == null ? void 0 : walletMachineState.value) != null ? _b : "uninitialized";
+    const authContext = (_c = authMachineState == null ? void 0 : authMachineState.context) != null ? _c : null;
+    const walletContext = (_d = walletMachineState == null ? void 0 : walletMachineState.context) != null ? _d : null;
+    return {
+      phase: coreStatePhase,
+      isLoading: this.isLoadingState({ coreStatePhase, authStatePhase, walletStatePhase }),
+      error: ((_e = xstate.context) == null ? void 0 : _e.error) || ((_f = authMachineState == null ? void 0 : authMachineState.context) == null ? void 0 : _f.error) || ((_g = walletMachineState == null ? void 0 : walletMachineState.context) == null ? void 0 : _g.error) || null,
+      isReady: !!((_h = xstate.context) == null ? void 0 : _h.isReady),
+      authStatePhase,
+      walletStatePhase,
+      // Computed auth state info for UI consumers
+      authStateInfo: this.computeAuthStateInfo(authContext, walletContext),
+      // Auth process
+      authStateResult: (authMachineState == null ? void 0 : authMachineState.context.authStateResult) || null,
+      needsWallet: (walletMachineState == null ? void 0 : walletMachineState.context.needsWallet) || false,
+      newWalletsResult: (walletMachineState == null ? void 0 : walletMachineState.context.newWalletsResult) || null,
+      externalWalletSignVerification: (authMachineState == null ? void 0 : authMachineState.context.externalWalletSignVerification) || null,
+      isNewUser: (authMachineState == null ? void 0 : authMachineState.context.isNewUser) || false,
+      // Wallet process
+      guestWallets: (walletMachineState == null ? void 0 : walletMachineState.context.guestWallets) || null
+    };
+  }
+  isLoadingState({
+    coreStatePhase,
+    authStatePhase,
+    walletStatePhase
+  }) {
+    return _CoreStateManager.CORE_LOADING_STATES.has(coreStatePhase) || _CoreStateManager.AUTH_LOADING_STATES.has(authStatePhase) || _CoreStateManager.WALLET_LOADING_STATES.has(walletStatePhase);
+  }
+  notifyListeners(state) {
+    if (this.lastNotifiedState && this.statesEqual(this.lastNotifiedState, state)) {
+      return;
+    }
+    this.lastNotifiedState = __spreadValues({}, state);
+    this.devLog("[CoreStateManager] State changed:", state);
+    this.listeners.forEach((listener) => {
+      try {
+        listener(state);
+      } catch (error) {
+        console.error("Error in state change listener:", error);
+      }
+    });
+  }
+  statesEqual(state1, state2) {
+    var _a, _b;
+    return state1.phase === state2.phase && state1.authStatePhase === state2.authStatePhase && state1.walletStatePhase === state2.walletStatePhase && state1.isLoading === state2.isLoading && state1.isReady === state2.isReady && state1.isNewUser === state2.isNewUser && state1.needsWallet === state2.needsWallet && ((_a = state1.error) == null ? void 0 : _a.message) === ((_b = state2.error) == null ? void 0 : _b.message) && state1.authStateResult === state2.authStateResult && state1.newWalletsResult === state2.newWalletsResult && state1.guestWallets === state2.guestWallets && state1.externalWalletSignVerification === state2.externalWalletSignVerification && this.authStateInfoEqual(state1.authStateInfo, state2.authStateInfo);
+  }
+  authStateInfoEqual(a, b) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+    return a.userId === b.userId && a.isPasskeySupported === b.isPasskeySupported && a.hasPasskey === b.hasPasskey && a.hasPassword === b.hasPassword && a.hasPin === b.hasPin && a.passkeyUrl === b.passkeyUrl && a.passkeyKnownDeviceUrl === b.passkeyKnownDeviceUrl && a.passwordUrl === b.passwordUrl && a.pinUrl === b.pinUrl && a.verificationUrl === b.verificationUrl && a.recoverySecret === b.recoverySecret && a.isNewUser === b.isNewUser && ((_a = a.externalWalletVerification) == null ? void 0 : _a.signatureVerificationMessage) === ((_b = b.externalWalletVerification) == null ? void 0 : _b.signatureVerificationMessage) && ((_c = a.externalWalletVerification) == null ? void 0 : _c.walletAddress) === ((_d = b.externalWalletVerification) == null ? void 0 : _d.walletAddress) && ((_e = a.externalWalletVerification) == null ? void 0 : _e.walletType) === ((_f = b.externalWalletVerification) == null ? void 0 : _f.walletType) && ((_g = a.passkeyHints) == null ? void 0 : _g.length) === ((_h = b.passkeyHints) == null ? void 0 : _h.length) && ((_i = a.passkeyHints) != null ? _i : []).every(
+      (hint, i) => hint.useragent === b.passkeyHints[i].useragent && hint.aaguid === b.passkeyHints[i].aaguid
+    );
+  }
+};
+_CoreStateManager.CORE_LOADING_STATES = /* @__PURE__ */ new Set([
+  "setting_up",
+  "waiting_for_external_wallet_providers",
+  "logging_out"
+]);
+_CoreStateManager.AUTH_LOADING_STATES = /* @__PURE__ */ new Set([
+  "authenticating_email_phone",
+  "authenticating_oauth",
+  "authenticating_external_wallet",
+  "authenticating_farcaster",
+  "processing_authentication",
+  "authenticating_telegram",
+  "checking_state"
+]);
+_CoreStateManager.WALLET_LOADING_STATES = /* @__PURE__ */ new Set([
+  "checking_wallet_state",
+  "claiming_wallets",
+  "creating_wallets",
+  "waiting_for_wallets",
+  "setting_up_after_login"
+]);
+let CoreStateManager = _CoreStateManager;
+export {
+  CoreStateManager
+};

package/dist/esm/state/actors/authenticateWithEmailOrPhone.js

@@ -0,0 +1,10 @@
+import {
+  __async
+} from "../../chunk-7B52C2XE.js";
+import { fromPromise } from "xstate";
+const createAuthenticateWithEmailOrPhoneActor = (authService) => fromPromise((params) => __async(void 0, null, function* () {
+  return yield authService.performSignUpOrLogIn(params.input);
+}));
+export {
+  createAuthenticateWithEmailOrPhoneActor
+};

package/dist/esm/state/actors/authenticateWithExternalWallet.js

@@ -0,0 +1,10 @@
+import {
+  __async
+} from "../../chunk-7B52C2XE.js";
+import { fromPromise } from "xstate";
+const createAuthenticateWithExternalWalletActor = (authService) => fromPromise((params) => __async(void 0, null, function* () {
+  return yield authService.performLoginExternalWallet(params.input);
+}));
+export {
+  createAuthenticateWithExternalWalletActor
+};

package/dist/esm/state/actors/authenticateWithFarcaster.js

@@ -0,0 +1,10 @@
+import {
+  __async
+} from "../../chunk-7B52C2XE.js";
+import { fromPromise } from "xstate";
+const createAuthenticateWithFarcasterActor = (pollingService) => fromPromise((params) => __async(void 0, null, function* () {
+  return yield pollingService.waitForFarcasterEvent(params.input);
+}));
+export {
+  createAuthenticateWithFarcasterActor
+};

package/dist/esm/state/actors/authenticateWithFarcasterLegacy.js

@@ -0,0 +1,10 @@
+import {
+  __async
+} from "../../chunk-7B52C2XE.js";
+import { fromPromise } from "xstate";
+const createAuthenticateWithFarcasterLegacyActor = (authService) => fromPromise((params) => __async(void 0, null, function* () {
+  return yield authService.performVerifyFarcaster(params.input);
+}));
+export {
+  createAuthenticateWithFarcasterLegacyActor
+};

package/dist/esm/state/actors/authenticateWithTelegram.js

@@ -0,0 +1,10 @@
+import {
+  __async
+} from "../../chunk-7B52C2XE.js";
+import { fromPromise } from "xstate";
+const createAuthenticateWithTelegramActor = (pollingService) => fromPromise((params) => __async(void 0, null, function* () {
+  return yield pollingService.waitForTelegramEvent(params.input);
+}));
+export {
+  createAuthenticateWithTelegramActor
+};

package/dist/esm/state/actors/authenticateWithTelegramLegacy.js

@@ -0,0 +1,10 @@
+import {
+  __async
+} from "../../chunk-7B52C2XE.js";
+import { fromPromise } from "xstate";
+const createAuthenticateWithTelegramLegacyActor = (authService) => fromPromise((params) => __async(void 0, null, function* () {
+  return yield authService.performVerifyTelegram(params.input);
+}));
+export {
+  createAuthenticateWithTelegramLegacyActor
+};

package/dist/esm/state/actors/checkUserState.js

@@ -0,0 +1,13 @@
+import {
+  __async
+} from "../../chunk-7B52C2XE.js";
+import { fromPromise } from "xstate";
+const createCheckUserStateActor = (paraCoreInterface) => fromPromise(() => __async(void 0, null, function* () {
+  const isAuthenticated = yield paraCoreInterface.sessionManagementService.isSessionActive();
+  const isFullyLoggedIn = yield paraCoreInterface.sessionManagementService.isFullyLoggedIn();
+  const isGuestMode = paraCoreInterface.pregenWalletService.isGuestMode;
+  return { isAuthenticated, isFullyLoggedIn, isGuestMode };
+}));
+export {
+  createCheckUserStateActor
+};

package/dist/esm/state/actors/claimWallets.js

@@ -0,0 +1,16 @@
+import {
+  __async
+} from "../../chunk-7B52C2XE.js";
+import { fromPromise } from "xstate";
+import { retryDelay, sleep } from "../../utils/retryBackoff.js";
+const createClaimWalletsActor = (pregenWalletService) => fromPromise(
+  (_0) => __async(void 0, [_0], function* ({ input }) {
+    var _a;
+    const retryCount = (_a = input == null ? void 0 : input.retryCount) != null ? _a : 0;
+    if (retryCount > 0) yield sleep(retryDelay(retryCount));
+    return yield pregenWalletService.performClaimPregenWallets();
+  })
+);
+export {
+  createClaimWalletsActor
+};

package/dist/esm/state/actors/connectExternalConnectors.js

@@ -0,0 +1,14 @@
+import {
+  __async
+} from "../../chunk-7B52C2XE.js";
+import { fromPromise } from "xstate";
+import { retryDelay, sleep } from "../../utils/retryBackoff.js";
+const createConnectParaConnectorsActor = (externalWalletService) => fromPromise((_0) => __async(void 0, [_0], function* ({ input }) {
+  var _a;
+  const retryCount = (_a = input == null ? void 0 : input.retryCount) != null ? _a : 0;
+  if (retryCount > 0) yield sleep(retryDelay(retryCount));
+  return yield externalWalletService.connectParaConnectors();
+}));
+export {
+  createConnectParaConnectorsActor
+};

package/dist/esm/state/actors/connectExternalWallet.js

@@ -0,0 +1,10 @@
+import {
+  __async
+} from "../../chunk-7B52C2XE.js";
+import { fromPromise } from "xstate";
+const createConnectExternalWalletActor = (externalWalletService) => fromPromise((params) => __async(void 0, null, function* () {
+  return yield externalWalletService.performConnectExternalWallet(params.input);
+}));
+export {
+  createConnectExternalWalletActor
+};

package/dist/esm/state/actors/createGuestWallets.js

@@ -0,0 +1,10 @@
+import {
+  __async
+} from "../../chunk-7B52C2XE.js";
+import { fromPromise } from "xstate";
+const createCreateGuestWalletsActor = (pregenWalletService) => fromPromise(() => __async(void 0, null, function* () {
+  return yield pregenWalletService.performCreateGuestWallets();
+}));
+export {
+  createCreateGuestWalletsActor
+};

package/dist/esm/state/actors/createWallets.js

@@ -0,0 +1,20 @@
+import {
+  __async,
+  __spreadValues
+} from "../../chunk-7B52C2XE.js";
+import { fromPromise } from "xstate";
+import { retryDelay, sleep } from "../../utils/retryBackoff.js";
+const createCreateWalletsActor = (walletService) => fromPromise((_0) => __async(void 0, [_0], function* ({ input }) {
+  var _a;
+  const retryCount = (_a = input == null ? void 0 : input.retryCount) != null ? _a : 0;
+  if (retryCount > 0) yield sleep(retryDelay(retryCount));
+  let { walletIds, recoverySecret } = input;
+  const created = yield walletService.createWalletPerType();
+  recoverySecret = recoverySecret != null ? recoverySecret : created.recoverySecret;
+  walletIds = __spreadValues(__spreadValues({}, walletIds), created.walletIds);
+  const resp = { walletIds, recoverySecret };
+  return resp;
+}));
+export {
+  createCreateWalletsActor
+};

package/dist/esm/state/actors/polling.js

@@ -0,0 +1,55 @@
+import {
+  __spreadProps,
+  __spreadValues
+} from "../../chunk-7B52C2XE.js";
+import { fromCallback } from "xstate";
+function createPollingActor(pollingService) {
+  return fromCallback(({ input, sendBack, receive }) => {
+    let isCanceled = false;
+    let callbacks = {
+      isCanceled: input.isCanceled,
+      onPoll: input.onPoll,
+      onCancel: input.onCancel
+    };
+    receive((event) => {
+      var _a;
+      if (event.type === "CANCEL") {
+        isCanceled = true;
+        (_a = callbacks.onCancel) == null ? void 0 : _a.call(callbacks);
+        sendBack({ type: "CANCEL" });
+      } else if (event.type === "UPDATE_CALLBACKS") {
+        callbacks = {
+          onPoll: event.data.onPoll || callbacks.onPoll,
+          onCancel: event.data.onCancel || callbacks.onCancel,
+          isCanceled: event.data.isCanceled || callbacks.isCanceled
+        };
+      }
+    });
+    const pollConfig = __spreadProps(__spreadValues({}, input), {
+      isCanceled: () => {
+        var _a;
+        return isCanceled || ((_a = callbacks.isCanceled) == null ? void 0 : _a.call(callbacks)) || false;
+      },
+      onPoll: callbacks.onPoll,
+      onCancel: callbacks.onCancel
+    });
+    pollingService.poll(pollConfig).then((result) => {
+      if (result.type === "COMPLETE") {
+        sendBack({ type: "COMPLETE", data: result.data });
+      } else if (result.type === "CANCEL") {
+        sendBack({ type: "CANCEL" });
+      } else {
+        sendBack({ type: "ERROR", error: result.error });
+      }
+    }).catch((error) => {
+      console.error("Polling service error:", error);
+      sendBack({ type: "ERROR", error: "POLLING_SERVICE_ERROR" });
+    });
+    return () => {
+      isCanceled = true;
+    };
+  });
+}
+export {
+  createPollingActor
+};

package/dist/esm/state/actors/processAuthentication.js

@@ -0,0 +1,10 @@
+import {
+  __async
+} from "../../chunk-7B52C2XE.js";
+import { fromPromise } from "xstate";
+const createProcessAuthenticationActor = (authService) => fromPromise((params) => __async(void 0, null, function* () {
+  return yield authService.prepareAuthState(params.input.authState, params.input.opts);
+}));
+export {
+  createProcessAuthenticationActor
+};

package/dist/esm/state/actors/setupAfterLogin.js

@@ -0,0 +1,12 @@
+import {
+  __async
+} from "../../chunk-7B52C2XE.js";
+import { fromPromise } from "xstate";
+const createSetupAfterLoginActor = (paraCoreInterface) => fromPromise(
+  (_0) => __async(void 0, [_0], function* ({ input: { temporaryShares, skipSessionRefresh } }) {
+    yield paraCoreInterface.setupAfterLogin({ temporaryShares, skipSessionRefresh });
+  })
+);
+export {
+  createSetupAfterLoginActor
+};

package/dist/esm/state/actors/setupPara.js

@@ -0,0 +1,10 @@
+import {
+  __async
+} from "../../chunk-7B52C2XE.js";
+import { fromPromise } from "xstate";
+const createSetupParaActor = (paraCoreInterface) => fromPromise(() => __async(void 0, null, function* () {
+  yield paraCoreInterface.setup();
+}));
+export {
+  createSetupParaActor
+};

package/dist/esm/state/actors/signExternalWalletVerification.js

@@ -0,0 +1,15 @@
+import {
+  __async,
+  __objRest,
+  __spreadValues
+} from "../../chunk-7B52C2XE.js";
+import { fromPromise } from "xstate";
+const createSignExternalWalletVerificationActor = (externalWalletService) => fromPromise(
+  (params) => __async(void 0, null, function* () {
+    const _a = yield externalWalletService.signMessage(params.input), { signature } = _a, rest = __objRest(_a, ["signature"]);
+    return __spreadValues({ externalWallet: params.input.externalWallet, signedMessage: signature }, rest);
+  })
+);
+export {
+  createSignExternalWalletVerificationActor
+};

package/dist/esm/state/actors/switchExternalWallet.js

@@ -0,0 +1,10 @@
+import {
+  __async
+} from "../../chunk-7B52C2XE.js";
+import { fromPromise } from "xstate";
+const createSwitchExternalWalletActor = (externalWalletService) => fromPromise((params) => __async(void 0, null, function* () {
+  return yield externalWalletService.performSwitchExternalWallet(params.input);
+}));
+export {
+  createSwitchExternalWalletActor
+};

package/dist/esm/state/actors/verifyExternalWallet.js

@@ -0,0 +1,10 @@
+import {
+  __async
+} from "../../chunk-7B52C2XE.js";
+import { fromPromise } from "xstate";
+const createVerifyExternalWalletActor = (authService) => fromPromise((params) => __async(void 0, null, function* () {
+  return yield authService.performVerifyExternalWallet(params.input);
+}));
+export {
+  createVerifyExternalWalletActor
+};

package/dist/esm/state/actors/verifyNewAccount.js

@@ -0,0 +1,10 @@
+import {
+  __async
+} from "../../chunk-7B52C2XE.js";
+import { fromPromise } from "xstate";
+const createVerifyNewAccountActor = (authService) => fromPromise((params) => __async(void 0, null, function* () {
+  return yield authService.performVerifyNewAccount(params.input);
+}));
+export {
+  createVerifyNewAccountActor
+};

package/dist/esm/state/actors/waitForExternalWalletProviders.js

@@ -0,0 +1,14 @@
+import {
+  __async
+} from "../../chunk-7B52C2XE.js";
+import { fromPromise } from "xstate";
+const createWaitForExternalWalletProvidersActor = (stateMachineInterface) => fromPromise(() => __async(void 0, null, function* () {
+  const resp = yield stateMachineInterface.externalWalletService.waitForProvidersLoading();
+  if (!resp) {
+    yield stateMachineInterface.logout();
+  }
+  return resp;
+}));
+export {
+  createWaitForExternalWalletProvidersActor
+};