@getpara/core-sdk 2.12.0 → 2.13.0

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

@@ -0,0 +1,343 @@
+import {
+  __async
+} from "../../chunk-7B52C2XE.js";
+import { assign, fromPromise, setup } from "xstate";
+import { createAuthStateMachine } from "./authStateMachine.js";
+import { createWalletStateMachine } from "./walletStateMachine.js";
+import { createSetupParaActor } from "../actors/setupPara.js";
+import { createWaitForExternalWalletProvidersActor } from "../actors/waitForExternalWalletProviders.js";
+import { dispatchEvent } from "../../utils/events.js";
+import { ParaEvent } from "../../index.js";
+function createCoreStateMachine(paraCoreInterface) {
+  return setup({
+    types: {
+      context: {}
+    },
+    actors: {
+      setupPara: createSetupParaActor(paraCoreInterface),
+      waitForExternalWalletProviders: createWaitForExternalWalletProvidersActor(paraCoreInterface),
+      authMachine: createAuthStateMachine(paraCoreInterface),
+      walletMachine: createWalletStateMachine(paraCoreInterface),
+      logoutPara: fromPromise(() => __async(this, null, function* () {
+        yield paraCoreInterface.logout();
+      }))
+    },
+    actions: {
+      spawnAuthMachine: assign({
+        authMachineRef: ({ spawn, self }) => {
+          paraCoreInterface.devLog("[core] Spawning auth machine");
+          return spawn("authMachine", { input: { coreRef: self } });
+        }
+      }),
+      spawnWalletMachine: 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: assign({
+        walletMachineRef: null
+      }),
+      clearState: assign({
+        authMachineRef: null,
+        walletMachineRef: null,
+        error: null,
+        setupRetryCount: 0,
+        lastErrorSource: null
+      }),
+      clearErrors: assign({
+        error: null
+      }),
+      setError: assign({
+        error: ({ event }) => event.error || new Error("An error occurred")
+      }),
+      setIsReady: assign({
+        isReady: true
+      }),
+      dispatchAuthenticatedEvent: ({ context }) => {
+        if (!context.authMachineRef.getSnapshot().context.isNewUser) {
+          dispatchEvent(ParaEvent.LOGIN_EVENT, true);
+          return;
+        }
+        dispatchEvent(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: assign({
+                error: () => new Error("External wallet providers failed to load after multiple attempts")
+              })
+            },
+            {
+              target: "setting_up",
+              guard: ({ event }) => event.output === false,
+              actions: 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: 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", 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"]
+          }
+        }
+      }
+    }
+  });
+}
+export {
+  createCoreStateMachine
+};