@getpara/core-sdk 2.12.0 → 2.13.0

package/dist/cjs/state/machines/authStateMachine.js

@@ -0,0 +1,1084 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var authStateMachine_exports = {};
+__export(authStateMachine_exports, {
+  createAuthStateMachine: () => createAuthStateMachine
+});
+module.exports = __toCommonJS(authStateMachine_exports);
+var import_xstate = require("xstate");
+var import_authenticateWithEmailOrPhone = require("../actors/authenticateWithEmailOrPhone.js");
+var import_authenticateWithExternalWallet = require("../actors/authenticateWithExternalWallet.js");
+var import_checkUserState = require("../actors/checkUserState.js");
+var import_processAuthentication = require("../actors/processAuthentication.js");
+var import_verifyNewAccount = require("../actors/verifyNewAccount.js");
+var import_polling = require("../actors/polling.js");
+var import_types = require("../../types/index.js");
+var import_verifyExternalWallet = require("../actors/verifyExternalWallet.js");
+var import_authenticateWithTelegram = require("../actors/authenticateWithTelegram.js");
+var import_authenticateWithFarcaster = require("../actors/authenticateWithFarcaster.js");
+var import_stateErrorHelpers = require("../../utils/stateErrorHelpers.js");
+var import_connectExternalWallet = require("../actors/connectExternalWallet.js");
+var import_signExternalWalletVerification = require("../actors/signExternalWalletVerification.js");
+var import_switchExternalWallet = require("../actors/switchExternalWallet.js");
+var import_authenticateWithTelegramLegacy = require("../actors/authenticateWithTelegramLegacy.js");
+var import_authenticateWithFarcasterLegacy = require("../actors/authenticateWithFarcasterLegacy.js");
+var import_events = require("../../utils/events.js");
+var import_authStateMachine_helpers = require("./authStateMachine.helpers.js");
+function createAuthStateMachine(paraCoreInterface) {
+  return (0, import_xstate.setup)({
+    types: {
+      context: {},
+      events: {},
+      input: {}
+    },
+    actors: {
+      checkUserState: (0, import_checkUserState.createCheckUserStateActor)(paraCoreInterface),
+      authenticateWithEmailOrPhone: (0, import_authenticateWithEmailOrPhone.createAuthenticateWithEmailOrPhoneActor)(paraCoreInterface.authService),
+      authenticateWithExternalWallet: (0, import_authenticateWithExternalWallet.createAuthenticateWithExternalWalletActor)(paraCoreInterface.authService),
+      authenticateWithTelegram: (0, import_authenticateWithTelegram.createAuthenticateWithTelegramActor)(paraCoreInterface.pollingService),
+      authenticateWithTelegramLegacy: (0, import_authenticateWithTelegramLegacy.createAuthenticateWithTelegramLegacyActor)(paraCoreInterface.authService),
+      authenticateWithFarcaster: (0, import_authenticateWithFarcaster.createAuthenticateWithFarcasterActor)(paraCoreInterface.pollingService),
+      authenticateWithFarcasterLegacy: (0, import_authenticateWithFarcasterLegacy.createAuthenticateWithFarcasterLegacyActor)(paraCoreInterface.authService),
+      processAuthentication: (0, import_processAuthentication.createProcessAuthenticationActor)(paraCoreInterface.authService),
+      verifyNewAccount: (0, import_verifyNewAccount.createVerifyNewAccountActor)(paraCoreInterface.authService),
+      verifyExternalWallet: (0, import_verifyExternalWallet.createVerifyExternalWalletActor)(paraCoreInterface.authService),
+      polling: (0, import_polling.createPollingActor)(paraCoreInterface.pollingService),
+      connectExternalWallet: (0, import_connectExternalWallet.createConnectExternalWalletActor)(paraCoreInterface.externalWalletService),
+      signExternalWalletVerification: (0, import_signExternalWalletVerification.createSignExternalWalletVerificationActor)(paraCoreInterface.externalWalletService),
+      switchExternalWallet: (0, import_switchExternalWallet.createSwitchExternalWalletActor)(paraCoreInterface.externalWalletService),
+      logoutActor: (0, import_xstate.fromPromise)(() => __async(this, null, function* () {
+        yield paraCoreInterface.logout({ skipStateReset: true });
+      }))
+    },
+    actions: {
+      logTransition: (_, params) => {
+        paraCoreInterface.devLog(`[auth] \u2192 ${params.to}${params.detail ? ` (${params.detail})` : ""}`);
+      },
+      fetchPregenWalletsFromOverride: (_, params) => {
+        void paraCoreInterface.pregenWalletService.fetchPregenWalletsFromOverride(params).catch((error) => console.error("Failed to fetch pregen wallets:", error));
+      },
+      storeAuthStateResult: (0, import_xstate.assign)({
+        authStateResult: ({ event }) => {
+          if ("output" in event) {
+            return event.output;
+          }
+          return null;
+        }
+      }),
+      setPollingCallbacks: (0, import_xstate.assign)({
+        pollingCallbacks: ({ event, context }) => {
+          if ("data" in event && event.data) {
+            return {
+              onCancel: "onCancel" in event.data ? event.data.onCancel : void 0,
+              onPoll: "onPoll" in event.data ? event.data.onPoll : void 0,
+              isCanceled: "isCanceled" in event.data ? event.data.isCanceled : void 0
+            };
+          }
+          return context.pollingCallbacks || null;
+        }
+      }),
+      setAutoCreate: (0, import_xstate.assign)({
+        shouldAutoCreateWallets: true
+      }),
+      setSessionOptions: (0, import_xstate.assign)({
+        shouldAutoCreateWallets: ({ event }) => {
+          if ("data" in event && event.data && typeof event.data === "object" && "autoCreateWallets" in event.data) {
+            return !!event.data.autoCreateWallets;
+          }
+          return false;
+        },
+        skipSessionRefreshOnSetup: ({ event }) => {
+          if ("data" in event && event.data && typeof event.data === "object" && "skipSessionRefresh" in event.data) {
+            return event.data.skipSessionRefresh || false;
+          }
+          return false;
+        }
+      }),
+      setIsLegacy: (0, import_xstate.assign)({
+        isLegacy: ({ event }) => "data" in event && "isLegacy" in event.data && event.data.isLegacy
+      }),
+      resetState: (0, import_xstate.assign)({
+        authStateResult: null,
+        serverAuthStateResult: null,
+        isNewUser: false,
+        error: null,
+        pollingCallbacks: null,
+        shouldAutoCreateWallets: false,
+        skipSessionRefreshOnSetup: false,
+        isLegacy: false,
+        retryAttempts: {},
+        externalWalletInfo: void 0,
+        externalWalletSignVerification: void 0
+      }),
+      resetError: (0, import_xstate.assign)({
+        error: null
+      }),
+      incrementRetryAttempt: (0, import_xstate.assign)({
+        retryAttempts: ({ context }, params) => {
+          var _a;
+          const newCount = (((_a = context.retryAttempts) == null ? void 0 : _a[params.type]) || 0) + 1;
+          paraCoreInterface.devLog(`[auth] Retry ${params.type}: attempt ${newCount}/3`);
+          return __spreadProps(__spreadValues({}, context.retryAttempts), {
+            [params.type]: newCount
+          });
+        }
+      }),
+      resetRetryAttempts: (0, import_xstate.assign)({
+        retryAttempts: {}
+      })
+    },
+    guards: {
+      isNewUser: ({ context }) => context.isNewUser,
+      authStageIsVerify: ({ context }) => {
+        var _a;
+        return ((_a = context.authStateResult) == null ? void 0 : _a.stage) === "verify";
+      },
+      authStageIsLogin: ({ context }) => {
+        var _a;
+        return ((_a = context.authStateResult) == null ? void 0 : _a.stage) === "login";
+      },
+      authStageIsSignup: ({ context }) => {
+        var _a;
+        return ((_a = context.authStateResult) == null ? void 0 : _a.stage) === "signup";
+      },
+      authStageIsDone: ({ context }) => {
+        var _a;
+        return ((_a = context.authStateResult) == null ? void 0 : _a.stage) === "done";
+      },
+      canRetryExternalWallet: ({ context }) => {
+        var _a;
+        return (((_a = context.retryAttempts) == null ? void 0 : _a.externalWalletVerification) || 0) < 3;
+      },
+      canRetryNewAccount: ({ context }) => {
+        var _a;
+        return (((_a = context.retryAttempts) == null ? void 0 : _a.newAccountVerification) || 0) < 3;
+      }
+    }
+  }).createMachine({
+    id: "auth",
+    initial: "checking_state",
+    context: ({ input: { coreRef } }) => ({
+      coreRef,
+      authStateResult: null,
+      serverAuthStateResult: null,
+      isNewUser: false,
+      error: null,
+      pollingCallbacks: null,
+      shouldAutoCreateWallets: false,
+      skipSessionRefreshOnSetup: false,
+      isLegacy: false,
+      retryAttempts: {}
+    }),
+    states: {
+      checking_state: {
+        invoke: {
+          src: "checkUserState",
+          onDone: [
+            {
+              guard: ({ event }) => {
+                const output = event.output;
+                return output.isGuestMode;
+              },
+              target: "guest_mode"
+            },
+            {
+              guard: ({ event }) => {
+                const output = event.output;
+                return paraCoreInterface.isPortal() && output.isAuthenticated || output.isFullyLoggedIn;
+              },
+              target: "authenticated"
+            },
+            { target: "clearing_state" }
+          ],
+          onError: {
+            target: "error",
+            actions: (0, import_authStateMachine_helpers.setAuthErrorAssign)("Failed to check authentication state")
+          }
+        }
+      },
+      clearing_state: {
+        invoke: {
+          src: "logoutActor",
+          onDone: "unauthenticated",
+          onError: "unauthenticated"
+        }
+      },
+      unauthenticated: {
+        on: __spreadProps(__spreadValues({}, import_authStateMachine_helpers.AUTH_RESTART_TRANSITIONS), {
+          INITIALIZE_GUEST_MODE: "guest_mode",
+          SESSION_IMPORTED: "authenticated"
+        })
+      },
+      guest_mode: {
+        entry: [
+          (0, import_xstate.sendTo)(({ context }) => context.coreRef, {
+            type: "GUEST_MODE"
+          })
+        ],
+        on: {
+          AUTHENTICATE_EMAIL_PHONE: "authenticating_email_phone",
+          AUTHENTICATE_OAUTH: "authenticating_oauth"
+        }
+      },
+      authenticating_email_phone: {
+        entry: ["setIsLegacy"],
+        invoke: {
+          src: "authenticateWithEmailOrPhone",
+          input: ({ event }) => {
+            if (event.type === "AUTHENTICATE_EMAIL_PHONE") {
+              return event.data;
+            }
+            throw new Error("Invalid event type for email/phone authentication");
+          },
+          onDone: [
+            {
+              target: "processing_authentication",
+              actions: [
+                (0, import_authStateMachine_helpers.setAuthResultAssign)(),
+                {
+                  type: "fetchPregenWalletsFromOverride",
+                  params: ({ event }) => {
+                    const output = event.output;
+                    return { authInfo: output.authState.auth };
+                  }
+                }
+              ]
+            }
+          ],
+          onError: {
+            target: "error",
+            actions: (0, import_authStateMachine_helpers.setAuthErrorAssign)("Email/phone authentication failed")
+          }
+        },
+        on: {
+          CANCEL: { target: "unauthenticated", actions: ["resetState"] }
+        }
+      },
+      authenticating_oauth: {
+        invoke: {
+          src: "polling",
+          input: ({ event }) => {
+            if (event.type === "AUTHENTICATE_OAUTH") {
+              const { onOAuthUrl, onOAuthPopup, method, appScheme, portalTheme, useShortUrls } = event.data;
+              let oauthSessionLookupId;
+              let oauthAuthState = null;
+              return {
+                init: () => __async(this, null, function* () {
+                  try {
+                    const { sessionLookupId } = yield paraCoreInterface.pollingService.initOAuthPolling({
+                      onOAuthPopup,
+                      onOAuthUrl,
+                      method,
+                      appScheme,
+                      portalTheme,
+                      useShortUrls
+                    });
+                    oauthSessionLookupId = sessionLookupId;
+                  } catch (error) {
+                    throw new Error(`OAuth initialization failed: ${(0, import_stateErrorHelpers.extractErrorMessage)(error, "Unknown error")}`);
+                  }
+                }),
+                checkCondition: () => __async(this, null, function* () {
+                  try {
+                    const result = yield paraCoreInterface.pollingService.waitForOAuth({
+                      onSuccess: (serverAuthState) => {
+                        oauthAuthState = serverAuthState;
+                      }
+                    })();
+                    return __spreadProps(__spreadValues({}, result), {
+                      data: {
+                        authState: oauthAuthState,
+                        sessionLookupId: oauthSessionLookupId,
+                        portalTheme: portalTheme || {},
+                        useShortUrls: useShortUrls || false
+                      }
+                    });
+                  } catch (error) {
+                    throw new Error(`OAuth polling failed: ${(0, import_stateErrorHelpers.extractErrorMessage)(error, "Unknown error")}`);
+                  }
+                }),
+                onPoll: () => {
+                  var _a, _b;
+                  return (_b = (_a = event.data).onPoll) == null ? void 0 : _b.call(_a);
+                },
+                onCancel: () => {
+                  var _a, _b;
+                  return (_b = (_a = event.data).onCancel) == null ? void 0 : _b.call(_a);
+                },
+                isCanceled: event.data.isCanceled || (() => false),
+                id: "authenticatingOauth"
+              };
+            }
+            throw new Error("Invalid event type for OAuth authentication");
+          },
+          onError: {
+            target: "error",
+            actions: (0, import_authStateMachine_helpers.setAuthErrorAssign)("OAuth authentication failed")
+          }
+        },
+        entry: [
+          (0, import_xstate.assign)({
+            pollingCallbacks: ({ event }) => {
+              if (event.type === "AUTHENTICATE_OAUTH") {
+                return {
+                  onPoll: event.data.onPoll,
+                  onCancel: event.data.onCancel,
+                  isCanceled: event.data.isCanceled
+                };
+              }
+              return null;
+            }
+          }),
+          "setIsLegacy"
+        ],
+        on: (0, import_authStateMachine_helpers.makePollingOnHandlers)("processing_authentication", "OAuth authentication failed", [
+          (0, import_xstate.assign)({
+            serverAuthStateResult: ({ event }) => {
+              var _a, _b, _c, _d;
+              const authState = ((_a = event.data) == null ? void 0 : _a.authState) || null;
+              return {
+                authState,
+                opts: {
+                  sessionLookupId: (_b = event.data) == null ? void 0 : _b.sessionLookupId,
+                  portalTheme: ((_c = event.data) == null ? void 0 : _c.portalTheme) || {},
+                  useShortUrls: ((_d = event.data) == null ? void 0 : _d.useShortUrls) || false,
+                  isFromExternalWallet: false
+                }
+              };
+            },
+            isNewUser: ({ event }) => {
+              var _a;
+              const authState = (_a = event.data) == null ? void 0 : _a.authState;
+              return authState ? (0, import_authStateMachine_helpers.computeIsNewUser)(authState) : false;
+            }
+          })
+        ])
+      },
+      switching_external_wallet: {
+        invoke: {
+          src: "switchExternalWallet",
+          input: ({ event }) => {
+            if (event.type === "SWITCH_EXTERNAL_WALLET") {
+              return event.data;
+            }
+            throw new Error("Invalid event type for external wallet authentication");
+          },
+          onDone: [
+            {
+              target: "authenticated",
+              actions: [
+                (0, import_xstate.assign)({
+                  externalWalletInfo: ({ event, context }) => {
+                    var _a;
+                    const output = event.output;
+                    return __spreadValues({
+                      externalWallet: __spreadValues(__spreadValues({}, output.externalWallet), (_a = context.externalWalletInfo) == null ? void 0 : _a.externalWallet)
+                    }, context.externalWalletInfo);
+                  }
+                })
+              ]
+            }
+          ],
+          onError: {
+            target: "error",
+            actions: (0, import_authStateMachine_helpers.setAuthErrorAssign)("External wallet authentication failed")
+          }
+        },
+        on: {
+          CANCEL: { target: "unauthenticated", actions: ["resetState"] }
+        }
+      },
+      connecting_external_wallet: {
+        invoke: {
+          src: "connectExternalWallet",
+          input: ({ event }) => {
+            if (event.type === "CONNECT_EXTERNAL_WALLET") {
+              return event.data;
+            }
+            throw new Error("Invalid event type for external wallet authentication");
+          },
+          onDone: [
+            {
+              target: "authenticating_external_wallet",
+              actions: [
+                (0, import_xstate.assign)({
+                  externalWalletInfo: ({ event }) => {
+                    const output = event.output;
+                    return output;
+                  }
+                })
+              ]
+            }
+          ],
+          onError: {
+            target: "error",
+            actions: (0, import_authStateMachine_helpers.setAuthErrorAssign)("External wallet authentication failed")
+          }
+        },
+        on: {
+          CANCEL: { target: "unauthenticated", actions: ["resetState"] }
+        }
+      },
+      authenticating_external_wallet: {
+        entry: [
+          (0, import_xstate.assign)({
+            externalWalletInfo: ({ event, context }) => {
+              var _a;
+              if (event.type === "AUTHENTICATE_EXTERNAL_WALLET" && ((_a = event.data) == null ? void 0 : _a.externalWallet)) {
+                const wallet = Array.isArray(event.data.externalWallet) ? event.data.externalWallet[0] : event.data.externalWallet;
+                return { externalWallet: wallet, chainId: event.data.chainId || "" };
+              }
+              return context.externalWalletInfo;
+            }
+          })
+        ],
+        invoke: {
+          src: "authenticateWithExternalWallet",
+          input: ({ event, context }) => {
+            if (event.type === "AUTHENTICATE_EXTERNAL_WALLET") {
+              return event.data;
+            }
+            if (context.externalWalletInfo) {
+              return context.externalWalletInfo;
+            }
+            throw new Error("No external wallet info available for authentication");
+          },
+          onDone: [
+            {
+              target: "processing_authentication",
+              actions: [(0, import_authStateMachine_helpers.setAuthResultAssign)(true)]
+            }
+          ],
+          onError: {
+            target: "error",
+            actions: (0, import_authStateMachine_helpers.setAuthErrorAssign)("External wallet authentication failed")
+          }
+        },
+        on: {
+          CANCEL: { target: "unauthenticated", actions: ["resetState"] }
+        }
+      },
+      authenticating_telegram_legacy: {
+        entry: [(0, import_xstate.assign)({ isLegacy: true })],
+        invoke: {
+          src: "authenticateWithTelegramLegacy",
+          input: ({ event }) => {
+            if (event.type === "AUTHENTICATE_TELEGRAM_LEGACY") {
+              return event.data;
+            }
+            throw new Error("Invalid event type for Telegram authentication");
+          },
+          onDone: [
+            {
+              target: "processing_authentication",
+              actions: [(0, import_authStateMachine_helpers.setAuthResultAssign)()]
+            }
+          ],
+          onError: [
+            {
+              target: "unauthenticated",
+              guard: ({ event }) => (0, import_authStateMachine_helpers.isCancelError)(event.error),
+              actions: ["resetState"]
+            },
+            {
+              target: "error",
+              actions: (0, import_authStateMachine_helpers.setAuthErrorAssign)("Telegram authentication failed")
+            }
+          ]
+        }
+      },
+      authenticating_telegram: {
+        entry: [
+          (0, import_xstate.assign)({
+            pollingCallbacks: ({ event }) => {
+              if (event.type === "AUTHENTICATE_TELEGRAM") {
+                return {
+                  isCanceled: event.data.isCanceled
+                };
+              }
+              return null;
+            },
+            isLegacy: false
+          })
+        ],
+        invoke: {
+          src: "authenticateWithTelegram",
+          input: ({ event }) => {
+            if (event.type === "AUTHENTICATE_TELEGRAM") {
+              return event.data;
+            }
+            throw new Error("Invalid event type for Telegram authentication");
+          },
+          onDone: [
+            {
+              target: "processing_authentication",
+              actions: [(0, import_authStateMachine_helpers.setAuthResultAssign)()]
+            }
+          ],
+          onError: [
+            {
+              target: "unauthenticated",
+              guard: ({ event }) => (0, import_authStateMachine_helpers.isCancelError)(event.error),
+              actions: ["resetState"]
+            },
+            {
+              target: "error",
+              actions: (0, import_authStateMachine_helpers.setAuthErrorAssign)("Telegram authentication failed")
+            }
+          ]
+        }
+      },
+      authenticating_farcaster_legacy: {
+        entry: [
+          (0, import_xstate.assign)({
+            pollingCallbacks: ({ event }) => {
+              if (event.type === "AUTHENTICATE_FARCASTER_LEGACY") {
+                return {
+                  onPoll: event.data.onPoll,
+                  onCancel: event.data.onCancel,
+                  isCanceled: event.data.isCanceled
+                };
+              }
+              return null;
+            }
+          }),
+          (0, import_xstate.assign)({ isLegacy: true })
+        ],
+        invoke: {
+          src: "authenticateWithFarcasterLegacy",
+          input: ({ event }) => {
+            if (event.type === "AUTHENTICATE_FARCASTER_LEGACY") {
+              return event.data;
+            }
+            throw new Error("Invalid event type for Farcaster authentication");
+          },
+          onDone: [
+            {
+              target: "waiting_for_farcaster",
+              guard: ({ event }) => {
+                const output = event.output;
+                return !output.authState;
+              }
+            },
+            {
+              target: "processing_authentication",
+              actions: [(0, import_authStateMachine_helpers.setAuthResultAssign)()]
+            }
+          ],
+          onError: [
+            {
+              target: "unauthenticated",
+              guard: ({ event }) => (0, import_authStateMachine_helpers.isCancelError)(event.error),
+              actions: ["resetState"]
+            },
+            {
+              target: "error",
+              actions: (0, import_authStateMachine_helpers.setAuthErrorAssign)("Farcaster authentication failed")
+            }
+          ]
+        }
+      },
+      waiting_for_farcaster: {
+        invoke: {
+          src: "polling",
+          input: ({ context }) => {
+            var _a;
+            let farcasterAuthState = null;
+            return {
+              checkCondition: () => __async(this, null, function* () {
+                try {
+                  const result = yield paraCoreInterface.pollingService.waitForFarcasterAuth({
+                    onSuccess: (serverAuthState) => {
+                      farcasterAuthState = serverAuthState;
+                    }
+                  })();
+                  return __spreadProps(__spreadValues({}, result), {
+                    data: {
+                      authState: farcasterAuthState
+                    }
+                  });
+                } catch (error) {
+                  throw new Error(`Farcaster polling failed: ${(0, import_stateErrorHelpers.extractErrorMessage)(error, "Unknown error")}`);
+                }
+              }),
+              onPoll: () => {
+                var _a2, _b;
+                return (_b = (_a2 = context.pollingCallbacks) == null ? void 0 : _a2.onPoll) == null ? void 0 : _b.call(_a2);
+              },
+              onCancel: () => {
+                var _a2, _b;
+                return (_b = (_a2 = context.pollingCallbacks) == null ? void 0 : _a2.onCancel) == null ? void 0 : _b.call(_a2);
+              },
+              isCanceled: ((_a = context.pollingCallbacks) == null ? void 0 : _a.isCanceled) || (() => false),
+              id: "waitingForFarcasterAuth"
+            };
+          },
+          onError: {
+            target: "error",
+            actions: (0, import_authStateMachine_helpers.setAuthErrorAssign)("Session waiting failed")
+          }
+        },
+        on: (0, import_authStateMachine_helpers.makePollingOnHandlers)("processing_authentication", "Session polling failed", [
+          (0, import_xstate.assign)({
+            serverAuthStateResult: ({ event, context }) => {
+              var _a, _b;
+              const authState = ((_a = event.data) == null ? void 0 : _a.authState) || null;
+              return {
+                authState,
+                opts: ((_b = context.serverAuthStateResult) == null ? void 0 : _b.opts) || import_authStateMachine_helpers.DEFAULT_AUTH_OPTS
+              };
+            },
+            isNewUser: ({ event }) => {
+              var _a;
+              const authState = (_a = event.data) == null ? void 0 : _a.authState;
+              return authState ? (0, import_authStateMachine_helpers.computeIsNewUser)(authState) : false;
+            }
+          })
+        ])
+      },
+      authenticating_farcaster: {
+        entry: [
+          (0, import_xstate.assign)({
+            pollingCallbacks: ({ event }) => {
+              if (event.type === "AUTHENTICATE_FARCASTER") {
+                return {
+                  isCanceled: event.data.isCanceled
+                };
+              }
+              return null;
+            },
+            isLegacy: false
+          })
+        ],
+        invoke: {
+          src: "authenticateWithFarcaster",
+          input: ({ event }) => {
+            if (event.type === "AUTHENTICATE_FARCASTER") {
+              return event.data;
+            }
+            throw new Error("Invalid event type for Farcaster authentication");
+          },
+          onDone: [
+            {
+              target: "processing_authentication",
+              actions: [(0, import_authStateMachine_helpers.setAuthResultAssign)()]
+            }
+          ],
+          onError: [
+            {
+              target: "unauthenticated",
+              guard: ({ event }) => (0, import_authStateMachine_helpers.isCancelError)(event.error),
+              actions: ["resetState"]
+            },
+            {
+              target: "error",
+              actions: (0, import_authStateMachine_helpers.setAuthErrorAssign)("Farcaster authentication failed")
+            }
+          ]
+        }
+      },
+      processing_authentication: {
+        entry: [{ type: "logTransition", params: { to: "processing_authentication" } }],
+        invoke: {
+          src: "processAuthentication",
+          input: ({ context }) => context.serverAuthStateResult,
+          onDone: [
+            {
+              target: "authenticated",
+              actions: [
+                "storeAuthStateResult",
+                { type: "logTransition", params: { to: "authenticated", detail: "external wallet, no full auth" } }
+              ],
+              guard: (0, import_xstate.and)([
+                ({ event }) => {
+                  const output = event.output;
+                  return !!output.externalWallet;
+                },
+                (0, import_xstate.or)([
+                  ({ event }) => {
+                    var _a;
+                    const output = event.output;
+                    return output.stage === "done" && !((_a = output.externalWallet) == null ? void 0 : _a.withFullParaAuth);
+                  },
+                  ({ event }) => {
+                    var _a, _b;
+                    const output = event.output;
+                    return output.stage === "verify" && !((_a = output.externalWallet) == null ? void 0 : _a.withFullParaAuth) && !((_b = output.externalWallet) == null ? void 0 : _b.withVerification);
+                  }
+                ])
+              ])
+            },
+            {
+              target: "verifying_external_wallet",
+              actions: [
+                "storeAuthStateResult",
+                {
+                  type: "logTransition",
+                  params: { to: "verifying_external_wallet", detail: "external wallet with verification" }
+                }
+              ],
+              guard: (0, import_xstate.and)([
+                ({ event }) => {
+                  const output = event.output;
+                  return !!output.externalWallet;
+                },
+                ({ event }) => {
+                  var _a, _b;
+                  const output = event.output;
+                  return output.stage === "verify" && !((_a = output.externalWallet) == null ? void 0 : _a.withFullParaAuth) && ((_b = output.externalWallet) == null ? void 0 : _b.withVerification);
+                }
+              ])
+            },
+            {
+              target: "awaiting_wallet_signature",
+              actions: [
+                "storeAuthStateResult",
+                {
+                  type: "logTransition",
+                  params: { to: "awaiting_wallet_signature", detail: "external wallet with full auth" }
+                }
+              ],
+              guard: (0, import_xstate.and)([
+                ({ event }) => {
+                  const output = event.output;
+                  return !!output.externalWallet;
+                },
+                ({ event }) => {
+                  var _a;
+                  const output = event.output;
+                  return output.stage === "verify" && !!((_a = output.externalWallet) == null ? void 0 : _a.withFullParaAuth);
+                }
+              ])
+            },
+            {
+              target: "awaiting_account_verification",
+              actions: [
+                "storeAuthStateResult",
+                { type: "logTransition", params: { to: "awaiting_account_verification", detail: "non-enclave verify" } }
+              ],
+              guard: (0, import_xstate.and)([
+                ({ event }) => {
+                  var _a;
+                  const output = event.output;
+                  return output.stage === "verify" && !((_a = output.externalWallet) == null ? void 0 : _a.withFullParaAuth);
+                },
+                () => !paraCoreInterface.authService.isEnclaveUser
+              ])
+            },
+            {
+              target: "awaiting_session_start",
+              actions: [
+                "storeAuthStateResult",
+                { type: "logTransition", params: { to: "awaiting_session_start", detail: "default route" } }
+              ]
+            }
+          ],
+          onError: {
+            target: "error",
+            actions: (0, import_authStateMachine_helpers.setAuthErrorAssign)("Authentication processing failed")
+          }
+        }
+      },
+      awaiting_wallet_signature: {
+        on: {
+          SIGN_EXTERNAL_WALLET_VERIFICATION: {
+            target: "signing_external_wallet_verification",
+            actions: ["resetError"]
+          },
+          CANCEL: { target: "unauthenticated", actions: ["resetState"] }
+        }
+      },
+      awaiting_wallet_verification: {
+        on: {
+          VERIFY_EXTERNAL_WALLET: {
+            target: "verifying_external_wallet",
+            actions: ["resetError"]
+          },
+          CANCEL: { target: "unauthenticated", actions: ["resetState"] }
+        }
+      },
+      awaiting_account_verification: {
+        on: {
+          VERIFY_NEW_ACCOUNT: {
+            target: "verifying_new_account",
+            guard: (0, import_xstate.and)(["authStageIsVerify", () => !paraCoreInterface.authService.isEnclaveUser]),
+            actions: ["resetError"]
+          },
+          CANCEL: { target: "unauthenticated", actions: ["resetState"] }
+        }
+      },
+      awaiting_session_start: {
+        on: {
+          WAIT_FOR_SESSION: {
+            target: "waiting_for_session",
+            actions: ["setPollingCallbacks", "setSessionOptions", "resetError"]
+          },
+          WAIT_FOR_WALLET_CREATION: {
+            target: "waiting_for_session",
+            actions: ["setPollingCallbacks", "setAutoCreate", "resetError"]
+          },
+          CANCEL: { target: "unauthenticated", actions: ["resetState"] }
+        }
+      },
+      verifying_new_account: {
+        invoke: {
+          src: "verifyNewAccount",
+          input: ({ event }) => {
+            if (event.type === "VERIFY_NEW_ACCOUNT") {
+              return event.data;
+            }
+            throw new Error("Invalid event type for new account verification");
+          },
+          onDone: {
+            target: "processing_authentication",
+            actions: ["resetRetryAttempts", (0, import_authStateMachine_helpers.setServerAuthStateAssign)()]
+          },
+          onError: [
+            {
+              target: "awaiting_account_verification",
+              guard: "canRetryNewAccount",
+              actions: [
+                {
+                  type: "incrementRetryAttempt",
+                  params: { type: "newAccountVerification" }
+                },
+                (0, import_authStateMachine_helpers.setAuthErrorAssign)("Account verification failed")
+              ]
+            },
+            {
+              target: "error",
+              actions: (0, import_xstate.assign)({
+                error: ({ event, context }) => {
+                  var _a;
+                  return (((_a = context.retryAttempts) == null ? void 0 : _a.newAccountVerification) || 0) >= 3 ? new Error("Account verification failed after max retries") : (0, import_stateErrorHelpers.formatStateError)(event.error, "Account verification failed");
+                }
+              })
+            }
+          ]
+        }
+      },
+      verifying_external_wallet: {
+        invoke: {
+          src: "verifyExternalWallet",
+          input: ({ event, context }) => {
+            var _a, _b;
+            if (event.type === "VERIFY_EXTERNAL_WALLET" && event.data) {
+              return event.data;
+            }
+            if (context.externalWalletInfo) {
+              const signatureVerificationMessage = (_b = (_a = context.authStateResult) == null ? void 0 : _a.signatureVerificationMessage) != null ? _b : "";
+              if (!signatureVerificationMessage) {
+                throw new Error("No signature verification message provided by server for external wallet verification");
+              }
+              return __spreadProps(__spreadValues({}, context.externalWalletInfo), {
+                signatureVerificationMessage
+              });
+            }
+            throw new Error("No external wallet info available for verification. Logout and try again.");
+          },
+          onDone: {
+            target: "processing_authentication",
+            actions: ["resetRetryAttempts", (0, import_authStateMachine_helpers.setServerAuthStateAssign)(true)]
+          },
+          onError: [
+            {
+              target: "awaiting_wallet_verification",
+              guard: "canRetryExternalWallet",
+              actions: [
+                {
+                  type: "incrementRetryAttempt",
+                  params: { type: "externalWalletVerification" }
+                },
+                (0, import_authStateMachine_helpers.setAuthErrorAssign)("External wallet verification failed")
+              ]
+            },
+            {
+              target: "error",
+              actions: (0, import_xstate.assign)({
+                error: ({ event, context }) => context.retryAttempts.externalWalletVerification >= 3 ? new Error("External wallet verification failed after max retries") : (0, import_stateErrorHelpers.formatStateError)(event.error, "External wallet verification failed")
+              })
+            }
+          ]
+        }
+      },
+      signing_external_wallet_verification: {
+        invoke: {
+          src: "signExternalWalletVerification",
+          input: ({ event, context }) => {
+            var _a;
+            if (event.type === "SIGN_EXTERNAL_WALLET_VERIFICATION") {
+              return __spreadProps(__spreadValues({}, event.data), { externalWallet: (_a = context.externalWalletInfo) == null ? void 0 : _a.externalWallet });
+            }
+            throw new Error("Invalid event type for external wallet verification");
+          },
+          onDone: {
+            target: "awaiting_wallet_verification",
+            actions: [
+              "resetRetryAttempts",
+              (0, import_xstate.assign)({
+                externalWalletSignVerification: ({ event }) => {
+                  return event.output;
+                }
+              })
+            ]
+          },
+          onError: [
+            {
+              target: "awaiting_wallet_signature",
+              guard: "canRetryExternalWallet",
+              actions: [
+                {
+                  type: "incrementRetryAttempt",
+                  params: { type: "externalWalletVerification" }
+                },
+                (0, import_authStateMachine_helpers.setAuthErrorAssign)("External wallet verification failed")
+              ]
+            },
+            {
+              target: "error",
+              actions: (0, import_xstate.assign)({
+                error: ({ event, context }) => context.retryAttempts.externalWalletVerification >= 3 ? new Error("External wallet verification failed after max retries") : (0, import_stateErrorHelpers.formatStateError)(event.error, "External wallet verification failed")
+              })
+            }
+          ]
+        },
+        on: {
+          CANCEL: { target: "unauthenticated", actions: ["resetState"] }
+        }
+      },
+      waiting_for_session: {
+        invoke: {
+          src: "polling",
+          input: ({ context }) => {
+            var _a;
+            return {
+              init: () => __async(this, null, function* () {
+                try {
+                  yield paraCoreInterface.sessionManagementService.touchSession();
+                  if (!paraCoreInterface.authService.isExternalWalletAuth) {
+                    paraCoreInterface.devLog("[waitingForSession] Clearing external wallets");
+                    paraCoreInterface.externalWalletService.externalWallets = {};
+                  }
+                } catch (error) {
+                  throw new Error(`Session touch failed: ${(0, import_stateErrorHelpers.extractErrorMessage)(error, "Unknown error")}`);
+                }
+              }),
+              checkCondition: () => __async(this, null, function* () {
+                try {
+                  return yield paraCoreInterface.pollingService.waitForSession();
+                } catch (error) {
+                  throw new Error(`Session polling failed: ${(0, import_stateErrorHelpers.extractErrorMessage)(error, "Unknown error")}`);
+                }
+              }),
+              onPoll: () => {
+                var _a2, _b;
+                return (_b = (_a2 = context.pollingCallbacks) == null ? void 0 : _a2.onPoll) == null ? void 0 : _b.call(_a2);
+              },
+              onCancel: () => {
+                var _a2, _b;
+                return (_b = (_a2 = context.pollingCallbacks) == null ? void 0 : _a2.onCancel) == null ? void 0 : _b.call(_a2);
+              },
+              isCanceled: ((_a = context.pollingCallbacks) == null ? void 0 : _a.isCanceled) || (() => false),
+              id: "waitingForSession"
+            };
+          },
+          onError: {
+            target: "error",
+            actions: (0, import_authStateMachine_helpers.setAuthErrorAssign)("Session waiting failed")
+          }
+        },
+        entry: ["setPollingCallbacks", { type: "logTransition", params: { to: "waiting_for_session" } }],
+        on: (0, import_authStateMachine_helpers.makePollingOnHandlers)("authenticated", "Session polling failed")
+      },
+      authenticated: {
+        entry: [
+          { type: "logTransition", params: { to: "authenticated" } },
+          (0, import_xstate.sendTo)(({ context }) => context.coreRef, {
+            type: "AUTHENTICATED"
+          }),
+          ({ context }) => {
+            if (context.isNewUser) {
+              (0, import_events.dispatchEvent)(import_types.ParaEvent.ACCOUNT_CREATION_EVENT, true);
+            }
+          }
+        ],
+        on: {
+          SWITCH_EXTERNAL_WALLET: {
+            target: "switching_external_wallet",
+            guard: (0, import_xstate.and)([() => paraCoreInterface.externalWalletService.externalWalletConnectionType !== "NONE"])
+          }
+        }
+      },
+      error: {
+        entry: [
+          ({ context }) => {
+            var _a;
+            paraCoreInterface.devLog(`[auth] \u2192 error: ${((_a = context.error) == null ? void 0 : _a.message) || "unknown"}`);
+          }
+        ],
+        on: __spreadProps(__spreadValues({}, (0, import_authStateMachine_helpers.makeErrorTransitions)(import_authStateMachine_helpers.AUTH_RESTART_TRANSITIONS)), {
+          RESET: {
+            target: "unauthenticated",
+            actions: "resetState"
+          }
+        })
+      }
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createAuthStateMachine
+});