@getpara/core-sdk 2.12.0 → 2.13.0

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

@@ -0,0 +1,383 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 coreStateMachine_exports = {};
+__export(coreStateMachine_exports, {
+  createCoreStateMachine: () => createCoreStateMachine
+});
+module.exports = __toCommonJS(coreStateMachine_exports);
+var import_xstate = require("xstate");
+var import_authStateMachine = require("./authStateMachine.js");
+var import_walletStateMachine = require("./walletStateMachine.js");
+var import_setupPara = require("../actors/setupPara.js");
+var import_waitForExternalWalletProviders = require("../actors/waitForExternalWalletProviders.js");
+var import_events = require("../../utils/events.js");
+var import__ = require("../../index.js");
+function createCoreStateMachine(paraCoreInterface) {
+  return (0, import_xstate.setup)({
+    types: {
+      context: {}
+    },
+    actors: {
+      setupPara: (0, import_setupPara.createSetupParaActor)(paraCoreInterface),
+      waitForExternalWalletProviders: (0, import_waitForExternalWalletProviders.createWaitForExternalWalletProvidersActor)(paraCoreInterface),
+      authMachine: (0, import_authStateMachine.createAuthStateMachine)(paraCoreInterface),
+      walletMachine: (0, import_walletStateMachine.createWalletStateMachine)(paraCoreInterface),
+      logoutPara: (0, import_xstate.fromPromise)(() => __async(this, null, function* () {
+        yield paraCoreInterface.logout();
+      }))
+    },
+    actions: {
+      spawnAuthMachine: (0, import_xstate.assign)({
+        authMachineRef: ({ spawn, self }) => {
+          paraCoreInterface.devLog("[core] Spawning auth machine");
+          return spawn("authMachine", { input: { coreRef: self } });
+        }
+      }),
+      spawnWalletMachine: (0, import_xstate.assign)(({ context, spawn }) => {
+        var _a, _b, _c, _d;
+        const authMachineSnapshot = context.authMachineRef.getSnapshot();
+        const authData = authMachineSnapshot.context;
+        const previousWalletSnapshot = (_b = (_a = context.walletMachineRef) == null ? void 0 : _a.getSnapshot) == null ? void 0 : _b.call(_a);
+        const previousWalletsResult = (_d = (_c = previousWalletSnapshot == null ? void 0 : previousWalletSnapshot.context) == null ? void 0 : _c.newWalletsResult) != null ? _d : null;
+        paraCoreInterface.devLog("[core] Spawning wallet machine");
+        return {
+          walletMachineRef: spawn("walletMachine", {
+            input: {
+              shouldAutoCreateWallets: (authData == null ? void 0 : authData.shouldAutoCreateWallets) || false,
+              authStateResult: authData == null ? void 0 : authData.authStateResult,
+              isNewUser: authData == null ? void 0 : authData.isNewUser,
+              isGuestMode: authMachineSnapshot.value === "guest_mode",
+              skipSessionRefreshOnSetup: (authData == null ? void 0 : authData.skipSessionRefreshOnSetup) || false,
+              previousWalletsResult
+            }
+          })
+        };
+      }),
+      clearWalletMachine: (0, import_xstate.assign)({
+        walletMachineRef: null
+      }),
+      clearState: (0, import_xstate.assign)({
+        authMachineRef: null,
+        walletMachineRef: null,
+        error: null,
+        setupRetryCount: 0,
+        lastErrorSource: null
+      }),
+      clearErrors: (0, import_xstate.assign)({
+        error: null
+      }),
+      setError: (0, import_xstate.assign)({
+        error: ({ event }) => event.error || new Error("An error occurred")
+      }),
+      setIsReady: (0, import_xstate.assign)({
+        isReady: true
+      }),
+      dispatchAuthenticatedEvent: ({ context }) => {
+        if (!context.authMachineRef.getSnapshot().context.isNewUser) {
+          (0, import_events.dispatchEvent)(import__.ParaEvent.LOGIN_EVENT, true);
+          return;
+        }
+        (0, import_events.dispatchEvent)(import__.ParaEvent.ACCOUNT_SETUP_EVENT, true);
+      }
+    }
+  }).createMachine({
+    id: "para",
+    initial: "setting_up",
+    context: {
+      authMachineRef: null,
+      walletMachineRef: null,
+      error: null,
+      isReady: false,
+      setupRetryCount: 0,
+      lastErrorSource: null
+    },
+    states: {
+      setting_up: {
+        invoke: {
+          src: "setupPara",
+          onDone: [
+            {
+              target: "waiting_for_external_wallet_providers",
+              guard: () => Object.keys(paraCoreInterface.externalWalletService.externalWallets).length > 0
+            },
+            {
+              target: "auth_flow",
+              actions: ["spawnAuthMachine", "setIsReady"]
+            }
+          ],
+          onError: { target: "error" }
+        }
+      },
+      waiting_for_external_wallet_providers: {
+        invoke: {
+          src: "waitForExternalWalletProviders",
+          onDone: [
+            {
+              target: "error",
+              guard: ({ event, context }) => event.output === false && context.setupRetryCount >= 2,
+              actions: (0, import_xstate.assign)({
+                error: () => new Error("External wallet providers failed to load after multiple attempts")
+              })
+            },
+            {
+              target: "setting_up",
+              guard: ({ event }) => event.output === false,
+              actions: (0, import_xstate.assign)({
+                authMachineRef: null,
+                walletMachineRef: null,
+                isReady: false,
+                error: null,
+                setupRetryCount: ({ context }) => context.setupRetryCount + 1
+              })
+            },
+            {
+              target: "auth_flow",
+              guard: ({ event }) => event.output === true,
+              actions: ["spawnAuthMachine", "setIsReady"]
+            }
+          ],
+          onError: { target: "error" }
+        }
+      },
+      auth_flow: {
+        on: {
+          // Forward events to auth machine
+          "AUTHENTICATE_EMAIL_PHONE": {
+            actions: ({ context, event }) => context.authMachineRef.send(event)
+          },
+          "AUTHENTICATE_OAUTH": {
+            actions: ({ context, event }) => context.authMachineRef.send(event)
+          },
+          "AUTHENTICATE_EXTERNAL_WALLET": {
+            actions: ({ context, event }) => context.authMachineRef.send(event)
+          },
+          "CONNECT_EXTERNAL_WALLET": {
+            actions: ({ context, event }) => context.authMachineRef.send(event)
+          },
+          "AUTHENTICATE_TELEGRAM": {
+            actions: ({ context, event }) => context.authMachineRef.send(event)
+          },
+          "AUTHENTICATE_TELEGRAM_LEGACY": {
+            actions: ({ context, event }) => context.authMachineRef.send(event)
+          },
+          "AUTHENTICATE_FARCASTER": {
+            actions: ({ context, event }) => context.authMachineRef.send(event)
+          },
+          "AUTHENTICATE_FARCASTER_LEGACY": {
+            actions: ({ context, event }) => context.authMachineRef.send(event)
+          },
+          "VERIFY_NEW_ACCOUNT": {
+            actions: ({ context, event }) => context.authMachineRef.send(event)
+          },
+          "VERIFY_EXTERNAL_WALLET": {
+            actions: ({ context, event }) => context.authMachineRef.send(event)
+          },
+          "SIGN_EXTERNAL_WALLET_VERIFICATION": {
+            actions: ({ context, event }) => context.authMachineRef.send(event)
+          },
+          "WAIT_FOR_SESSION": {
+            actions: ({ context, event }) => context.authMachineRef.send(event)
+          },
+          // During auth_flow, WAIT_FOR_WALLET_CREATION is forwarded to the auth machine
+          // where it signals wallet readiness on the auth side. During wallet_flow (below),
+          // the same event is forwarded to the wallet machine to trigger actual wallet creation.
+          "WAIT_FOR_WALLET_CREATION": {
+            actions: ({ context, event }) => context.authMachineRef.send(event)
+          },
+          "INITIALIZE_GUEST_MODE": {
+            actions: ({ context, event }) => context.authMachineRef.send(event)
+          },
+          "SESSION_IMPORTED": {
+            actions: ({ context, event }) => context.authMachineRef.send(event)
+          },
+          "CANCEL": {
+            actions: ({ context, event }) => context.authMachineRef.send(event)
+          },
+          // Pass logout event through to reset auth flow
+          "LOGOUT": {
+            target: "logging_out"
+          },
+          // Listen for auth machine authenticated
+          "AUTHENTICATED": [
+            {
+              guard: ({ context }) => context.walletMachineRef === null,
+              target: "wallet_flow",
+              actions: "spawnWalletMachine"
+            }
+          ],
+          // Listen for auth machine in guest mode
+          "GUEST_MODE": [
+            {
+              guard: ({ context }) => context.walletMachineRef === null,
+              target: "wallet_flow",
+              actions: "spawnWalletMachine"
+            }
+          ],
+          // Handle auth machine errors
+          "xstate.error.actor.*": {
+            guard: ({ event, context }) => event.actorId === context.authMachineRef.id,
+            target: "error",
+            actions: "setError"
+          }
+        }
+      },
+      wallet_flow: {
+        on: {
+          // Forward wallet events
+          "WAIT_FOR_WALLET_CREATION": {
+            actions: ({ context, event }) => context.walletMachineRef.send(event)
+          },
+          "LOGOUT": {
+            target: "logging_out"
+          },
+          // Listen for wallet machine completion
+          "xstate.done.actor.*": [
+            {
+              target: "guest_mode",
+              guard: ({ event, context }) => {
+                const isWalletMachine = event.actorId === context.walletMachineRef.id;
+                const walletSnapshot = context.walletMachineRef.getSnapshot();
+                const isGuestMode = walletSnapshot.value === "guest_mode";
+                return isWalletMachine && isGuestMode;
+              }
+            },
+            {
+              target: "authenticated",
+              guard: ({ event, context }) => {
+                const isWalletMachine = event.actorId === context.walletMachineRef.id;
+                const walletSnapshot = context.walletMachineRef.getSnapshot();
+                const isDone = walletSnapshot.value === "wallets_ready" || walletSnapshot.value === "no_wallets_needed";
+                return isWalletMachine && isDone;
+              }
+            },
+            {
+              target: "error",
+              guard: ({ event, context }) => {
+                const isWalletMachine = event.actorId === context.walletMachineRef.id;
+                if (!isWalletMachine) return false;
+                const walletSnapshot = context.walletMachineRef.getSnapshot();
+                const hasError = walletSnapshot.value === "error";
+                return hasError;
+              },
+              actions: (0, import_xstate.assign)({
+                error: ({ context }) => {
+                  var _a;
+                  const walletSnapshot = context.walletMachineRef.getSnapshot();
+                  return ((_a = walletSnapshot.context) == null ? void 0 : _a.error) || new Error("Wallet setup failed");
+                },
+                lastErrorSource: () => "wallet"
+              })
+            }
+          ],
+          // Handle wallet machine errors
+          "xstate.error.actor.*": {
+            guard: ({ event, context }) => event.actorId === context.walletMachineRef.id,
+            target: "error",
+            actions: ["setError", (0, import_xstate.assign)({ lastErrorSource: () => "wallet" })]
+          }
+        }
+      },
+      authenticated: {
+        entry: ["dispatchAuthenticatedEvent"],
+        on: {
+          LOGOUT: {
+            target: "logging_out"
+          },
+          SWITCH_EXTERNAL_WALLET: {
+            actions: ({ context, event }) => context.authMachineRef.send(event)
+          }
+        }
+      },
+      guest_mode: {
+        on: {
+          LOGOUT: {
+            target: "logging_out"
+          },
+          AUTHENTICATE_EMAIL_PHONE: {
+            actions: ["clearWalletMachine", ({ context, event }) => context.authMachineRef.send(event)]
+          },
+          AUTHENTICATE_OAUTH: {
+            actions: ["clearWalletMachine", ({ context, event }) => context.authMachineRef.send(event)]
+          },
+          WAIT_FOR_SESSION: {
+            actions: ({ context, event }) => context.authMachineRef.send(event)
+          },
+          // Listen for auth machine authenticated
+          AUTHENTICATED: [
+            {
+              guard: ({ context }) => context.walletMachineRef === null,
+              target: "wallet_flow",
+              actions: "spawnWalletMachine"
+            }
+          ]
+        }
+      },
+      logging_out: {
+        entry: ["clearState"],
+        invoke: {
+          src: "logoutPara",
+          onDone: {
+            target: "auth_flow",
+            actions: ["spawnAuthMachine", "setIsReady"]
+          },
+          onError: {
+            // Still proceed even if logout fails
+            target: "auth_flow",
+            actions: ["spawnAuthMachine", "setIsReady"]
+          }
+        }
+      },
+      error: {
+        on: {
+          LOGOUT: {
+            target: "logging_out"
+          },
+          RETRY_WALLET_FLOW: {
+            target: "wallet_flow",
+            guard: ({ context }) => context.lastErrorSource === "wallet",
+            actions: ["clearErrors", "spawnWalletMachine"]
+          }
+        }
+      }
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createCoreStateMachine
+});