@getpara/core-sdk 2.12.0 → 2.14.0

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

@@ -0,0 +1,401 @@
+import {
+  __async,
+  __spreadProps,
+  __spreadValues
+} from "../../chunk-7B52C2XE.js";
+import { assign, setup, or, and } from "xstate";
+import { createPollingActor } from "../actors/polling.js";
+import { createClaimWalletsActor } from "../actors/claimWallets.js";
+import { createCreateWalletsActor } from "../actors/createWallets.js";
+import { createSetupAfterLoginActor } from "../actors/setupAfterLogin.js";
+import { extractErrorMessage, formatStateError } from "../../utils/stateErrorHelpers.js";
+import { createConnectParaConnectorsActor } from "../actors/connectExternalConnectors.js";
+import { createCreateGuestWalletsActor } from "../actors/createGuestWallets.js";
+function createWalletStateMachine(paraCoreInterface) {
+  return setup({
+    types: {
+      context: {},
+      events: {}
+    },
+    actors: {
+      polling: createPollingActor(paraCoreInterface.pollingService),
+      claimWallets: createClaimWalletsActor(paraCoreInterface.pregenWalletService),
+      createWallets: createCreateWalletsActor(paraCoreInterface.walletService),
+      setupAfterLogin: createSetupAfterLoginActor(paraCoreInterface),
+      connectParaConnectors: createConnectParaConnectorsActor(paraCoreInterface.externalWalletService),
+      createGuestWallets: createCreateGuestWalletsActor(paraCoreInterface.pregenWalletService)
+    },
+    actions: {
+      setPollingCallbacks: assign({
+        pollingCallbacks: ({ event }) => {
+          if ("data" in event && event.data && typeof event.data === "object" && "pollingCallbacks" in event.data) {
+            return event.data.pollingCallbacks || null;
+          }
+          return null;
+        }
+      }),
+      incrementWalletRetry: assign({
+        retryAttempts: ({ context }, params) => {
+          var _a;
+          const newCount = (((_a = context.retryAttempts) == null ? void 0 : _a[params.type]) || 0) + 1;
+          paraCoreInterface.devLog(`[wallet] Retry ${params.type}: attempt ${newCount}/3`);
+          return __spreadProps(__spreadValues({}, context.retryAttempts), {
+            [params.type]: newCount
+          });
+        }
+      })
+    },
+    guards: {
+      canRetryClaiming: ({ context }) => {
+        var _a;
+        return (((_a = context.retryAttempts) == null ? void 0 : _a.claiming) || 0) < 3;
+      },
+      canRetryCreating: ({ context }) => {
+        var _a;
+        return (((_a = context.retryAttempts) == null ? void 0 : _a.creating) || 0) < 3;
+      },
+      canRetryConnecting: ({ context }) => {
+        var _a;
+        return (((_a = context.retryAttempts) == null ? void 0 : _a.connecting) || 0) < 3;
+      },
+      isNoWalletConfig: () => paraCoreInterface.isNoWalletConfig,
+      isExternalWalletConnectionOnly: () => paraCoreInterface.externalWalletService.externalWalletConnectionType === "CONNECTION_ONLY" || paraCoreInterface.externalWalletService.externalWalletConnectionType === "VERIFICATION",
+      isNewUser: ({ context }) => {
+        var _a;
+        return ((_a = context.authData) == null ? void 0 : _a.isNewUser) || false;
+      },
+      shouldAutoCreate: ({ context }) => {
+        var _a;
+        return ((_a = context.authData) == null ? void 0 : _a.shouldAutoCreateWallets) || false;
+      },
+      needsWallets: ({ context }) => context.needsWallet,
+      isLegacyOrEnclaveLogin: ({ context }) => {
+        var _a, _b;
+        const stage = (_b = (_a = context.authData) == null ? void 0 : _a.authStateResult) == null ? void 0 : _b.stage;
+        return stage === "login" || stage === "done" || stage === "verify" && paraCoreInterface.authService.isEnclaveUser;
+      },
+      hasPreviousWalletsResult: ({ context }) => context.newWalletsResult !== null,
+      isWalletsAlreadySetUp: ({ context }) => {
+        var _a, _b;
+        const stage = (_b = (_a = context.authData) == null ? void 0 : _a.authStateResult) == null ? void 0 : _b.stage;
+        const isLogin = stage === "login" || stage === "done";
+        if (!isLogin) return false;
+        const currentIds = paraCoreInterface.walletService.currentWalletIdsArray;
+        if (currentIds.length === 0) return false;
+        return currentIds.every(([walletId]) => {
+          const wallet = paraCoreInterface.walletService.wallets[walletId];
+          return wallet && !!wallet.signer;
+        });
+      },
+      // Check if the auth state is guest mode
+      isGuestMode: ({ context }) => {
+        var _a;
+        return ((_a = context.authData) == null ? void 0 : _a.isGuestMode) || false;
+      },
+      // Check if the user actually needs guest wallets created
+      needsGuestWallets: () => !paraCoreInterface.pregenWalletService.isGuestMode,
+      // Check if the user should claim guest wallets
+      shouldClaimGuestWallets: () => paraCoreInterface.pregenWalletService.isGuestMode
+    }
+  }).createMachine({
+    id: "wallets",
+    initial: "checking_wallet_state",
+    context: ({ input }) => ({
+      needsWallet: false,
+      newWalletsResult: (input == null ? void 0 : input.previousWalletsResult) || null,
+      temporaryShares: null,
+      pollingCallbacks: null,
+      error: null,
+      authData: {
+        isNewUser: (input == null ? void 0 : input.isNewUser) || false,
+        authStateResult: (input == null ? void 0 : input.authStateResult) || null,
+        shouldAutoCreateWallets: (input == null ? void 0 : input.shouldAutoCreateWallets) || false,
+        skipSessionRefreshOnSetup: (input == null ? void 0 : input.skipSessionRefreshOnSetup) || false,
+        isGuestMode: (input == null ? void 0 : input.isGuestMode) || false
+      },
+      guestWallets: null,
+      retryAttempts: {}
+    }),
+    states: {
+      checking_wallet_state: {
+        always: [
+          {
+            target: "creating_guest_wallets",
+            guard: and(["isGuestMode", "needsGuestWallets"])
+          },
+          {
+            target: "guest_mode",
+            guard: and(["isGuestMode"])
+          },
+          {
+            target: "no_wallets_needed",
+            guard: or(["isNoWalletConfig", "isExternalWalletConnectionOnly"])
+          },
+          {
+            // Skip claiming if we already have wallet results from a previous attempt
+            target: "creating_wallets",
+            guard: and(["hasPreviousWalletsResult", or(["isNewUser", "shouldAutoCreate"])])
+          },
+          {
+            target: "claiming_wallets",
+            guard: and([or(["isNewUser", "shouldClaimGuestWallets"]), "shouldAutoCreate"])
+          },
+          {
+            target: "needs_wallets",
+            guard: "isNewUser"
+          },
+          {
+            // Wallets already set up (e.g., by loginWithPasskey on mobile) — still
+            // go through creating_wallets so any missing provider-required types
+            // get created. createWalletPerType is idempotent (checks #getMissingTypes).
+            target: "creating_wallets",
+            guard: "isWalletsAlreadySetUp"
+          },
+          {
+            target: "waiting_for_wallets",
+            guard: "isLegacyOrEnclaveLogin"
+          },
+          {
+            target: "connecting_para_connectors"
+          }
+        ]
+      },
+      needs_wallets: {
+        on: {
+          WAIT_FOR_WALLET_CREATION: {
+            target: "claiming_wallets",
+            actions: "setPollingCallbacks"
+          }
+        }
+      },
+      creating_guest_wallets: {
+        invoke: {
+          src: "createGuestWallets",
+          onDone: [
+            {
+              target: "guest_mode",
+              actions: assign({
+                guestWallets: ({ event }) => {
+                  return event.output || null;
+                }
+              })
+            }
+          ],
+          onError: {
+            target: "error",
+            actions: assign({
+              error: ({ event }) => formatStateError(event.error, "Failed to create guest wallets")
+            })
+          }
+        }
+      },
+      claiming_wallets: {
+        invoke: {
+          src: "claimWallets",
+          input: ({ context }) => {
+            var _a, _b;
+            return { retryCount: (_b = (_a = context.retryAttempts) == null ? void 0 : _a.claiming) != null ? _b : 0 };
+          },
+          onDone: [
+            {
+              target: "creating_wallets",
+              actions: assign({
+                newWalletsResult: ({ event }) => {
+                  return event.output || null;
+                }
+              }),
+              guard: or(["isNewUser", "needsWallets"])
+            },
+            {
+              target: "connecting_para_connectors"
+            }
+          ],
+          onError: [
+            {
+              target: "claiming_wallets",
+              guard: "canRetryClaiming",
+              actions: [{ type: "incrementWalletRetry", params: { type: "claiming" } }]
+            },
+            {
+              target: "error",
+              actions: assign({
+                error: ({ event }) => formatStateError(event.error, "Failed to claim wallets")
+              })
+            }
+          ]
+        }
+      },
+      creating_wallets: {
+        invoke: {
+          src: "createWallets",
+          input: ({ context }) => {
+            var _a, _b;
+            return __spreadProps(__spreadValues({}, context.newWalletsResult), { retryCount: (_b = (_a = context.retryAttempts) == null ? void 0 : _a.creating) != null ? _b : 0 });
+          },
+          onDone: {
+            target: "connecting_para_connectors",
+            actions: assign({
+              newWalletsResult: ({ event }) => {
+                return event.output || null;
+              }
+            })
+          },
+          onError: [
+            {
+              target: "creating_wallets",
+              guard: "canRetryCreating",
+              actions: [{ type: "incrementWalletRetry", params: { type: "creating" } }]
+            },
+            {
+              target: "error",
+              actions: assign({
+                error: ({ event }) => formatStateError(event.error, "Failed to create wallets")
+              })
+            }
+          ]
+        }
+      },
+      waiting_for_wallets: {
+        invoke: {
+          src: "polling",
+          input: ({ context, self }) => {
+            var _a;
+            return {
+              checkCondition: () => __async(this, null, function* () {
+                try {
+                  return yield paraCoreInterface.pollingService.waitForWallets({ parent: self })();
+                } catch (error) {
+                  throw new Error(`Wallet polling failed: ${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: "waitingForWallets"
+            };
+          },
+          onError: {
+            target: "error",
+            actions: assign({
+              error: ({ event }) => formatStateError(event.error, "Wallet polling failed")
+            })
+          }
+        },
+        entry: "setPollingCallbacks",
+        on: {
+          SET_NEEDS_WALLET: {
+            actions: assign({
+              needsWallet: ({ event }) => {
+                if ("data" in event && event.data && typeof event.data === "object" && "needsWallet" in event.data) {
+                  return Boolean(event.data.needsWallet);
+                }
+                return false;
+              }
+            })
+          },
+          SET_TEMPORARY_SHARES: {
+            actions: assign({
+              temporaryShares: ({ event }) => {
+                if ("data" in event && event.data && typeof event.data === "object" && "temporaryShares" in event.data) {
+                  return event.data.temporaryShares;
+                }
+                return null;
+              }
+            })
+          },
+          COMPLETE: [
+            {
+              target: "needs_wallets",
+              guard: "needsWallets"
+            },
+            {
+              target: "setting_up_after_login"
+            }
+          ],
+          CANCEL: [
+            {
+              target: "checking_wallet_state"
+            }
+          ],
+          ERROR: {
+            target: "error",
+            actions: assign({
+              error: ({ event }) => formatStateError(event.error, "Wallet polling failed")
+            })
+          }
+        }
+      },
+      setting_up_after_login: {
+        invoke: {
+          src: "setupAfterLogin",
+          input: ({ context }) => {
+            var _a;
+            return {
+              temporaryShares: context.temporaryShares,
+              skipSessionRefresh: ((_a = context.authData) == null ? void 0 : _a.skipSessionRefreshOnSetup) || false
+            };
+          },
+          onDone: {
+            target: "claiming_wallets",
+            actions: assign({
+              // Reset temporary shares after successful setup
+              temporaryShares: null
+            })
+          },
+          onError: {
+            target: "error",
+            actions: assign({
+              error: ({ event }) => formatStateError(event.error, "Failed to setup after login")
+            })
+          }
+        }
+      },
+      connecting_para_connectors: {
+        invoke: {
+          src: "connectParaConnectors",
+          input: ({ context }) => {
+            var _a, _b;
+            return { retryCount: (_b = (_a = context.retryAttempts) == null ? void 0 : _a.connecting) != null ? _b : 0 };
+          },
+          onDone: {
+            target: "wallets_ready"
+          },
+          onError: [
+            {
+              target: "connecting_para_connectors",
+              guard: "canRetryConnecting",
+              actions: [{ type: "incrementWalletRetry", params: { type: "connecting" } }]
+            },
+            {
+              target: "error",
+              actions: assign({
+                error: ({ event }) => formatStateError(event.error, "Failed to connect Para connectors")
+              })
+            }
+          ]
+        }
+      },
+      no_wallets_needed: {
+        type: "final"
+      },
+      wallets_ready: {
+        type: "final"
+      },
+      guest_mode: {
+        type: "final"
+      },
+      error: {
+        type: "final"
+      }
+    }
+  });
+}
+export {
+  createWalletStateMachine
+};

package/dist/esm/types/coreApi.js

@@ -50,7 +50,9 @@ const PARA_CORE_METHODS = [
   "getLinkedAccounts",
   "accountLinkInProgress",
   "addCredential",
-  "exportPrivateKey"
+  "exportPrivateKey",
+  "authenticateWithEmailOrPhone",
+  "authenticateWithOAuth"
 ];
 const PARA_INTERNAL_METHODS = [
   "linkAccount",

package/dist/esm/types/index.js

@@ -1,4 +1,4 @@
-export * from "./auth.js";
+export * from "./accountLinking.js";
 export * from "./config.js";
 export * from "./coreApi.js";
 export * from "./wallet.js";

package/dist/esm/utils/formatting.js

@@ -49,6 +49,9 @@ function rawSecp256k1PubkeyToRawAddress(pubkeyData) {
   return ripemd160(sha256(pubkeyData));
 }
 function getCosmosAddress(publicKey, prefix) {
+  if (!publicKey || publicKey.length === 0) {
+    return "";
+  }
   const uncompressedPublicKey = new Uint8Array(
     Buffer.from(publicKey.startsWith("0x") ? publicKey.slice(2) : publicKey, "hex")
   );
@@ -59,6 +62,9 @@ function truncateAddress(str, addressType, {
   prefix = addressType === "COSMOS" ? "cosmos" : void 0,
   targetLength
 } = {}) {
+  if (!str || str.length === 0) {
+    return "";
+  }
   const minimum = addressType === "COSMOS" ? prefix.length : addressType === "EVM" ? 2 : 0;
   const margin = targetLength !== void 0 ? (targetLength - minimum) / 2 : 4;
   return `${str.slice(0, minimum + margin)}...${str.slice(-1 * margin)}`;

package/dist/esm/utils/retryBackoff.js

@@ -0,0 +1,7 @@
+import "../chunk-7B52C2XE.js";
+const retryDelay = (attempt) => Math.min(100 * Math.pow(2, attempt), 2e3);
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+export {
+  retryDelay,
+  sleep
+};

package/dist/esm/utils/stateErrorHelpers.js

@@ -0,0 +1,37 @@
+import "../chunk-7B52C2XE.js";
+function extractErrorMessage(error, defaultMessage) {
+  if (typeof error === "string") {
+    return error;
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (error && typeof error === "object" && "message" in error) {
+    return String(error.message);
+  }
+  if (error && typeof error === "object" && "error" in error) {
+    return extractErrorMessage(error.error, defaultMessage);
+  }
+  console.error("Unexpected error format:", error);
+  return defaultMessage;
+}
+function formatStateError(error, defaultMessage) {
+  if (error instanceof Error) {
+    return error;
+  }
+  if (typeof error === "string") {
+    return new Error(error);
+  }
+  if (error && typeof error === "object" && "message" in error) {
+    return new Error(String(error.message));
+  }
+  if (error && typeof error === "object" && "error" in error) {
+    return formatStateError(error.error, defaultMessage);
+  }
+  console.error("Unexpected error format:", error);
+  return new Error(defaultMessage);
+}
+export {
+  extractErrorMessage,
+  formatStateError
+};

package/dist/esm/utils/stateListener.js

@@ -0,0 +1,106 @@
+import "../chunk-7B52C2XE.js";
+function createStateListener({
+  stateManager,
+  shouldResolve,
+  shouldReject,
+  onReject,
+  rejectInErrorPhaseOnly,
+  timeoutMs = 3e5
+}) {
+  return new Promise((resolve, reject) => {
+    let unsubscribe;
+    let timer;
+    const cleanup = () => {
+      unsubscribe == null ? void 0 : unsubscribe();
+      if (timer) clearTimeout(timer);
+    };
+    timer = setTimeout(() => {
+      cleanup();
+      reject(new Error("State listener timed out"));
+    }, timeoutMs);
+    unsubscribe = stateManager.onStateChange((state) => {
+      const isInErrorPhase = state.phase === "error" || state.authStatePhase === "error" || state.walletStatePhase === "error";
+      if (rejectInErrorPhaseOnly ? isInErrorPhase : state.error) {
+        cleanup();
+        onReject == null ? void 0 : onReject(state);
+        reject(state.error);
+        return;
+      }
+      if (shouldReject) {
+        const error = shouldReject(state);
+        if (error) {
+          cleanup();
+          onReject == null ? void 0 : onReject(state);
+          reject(error);
+          return;
+        }
+      }
+      const result = shouldResolve(state);
+      if (result !== null) {
+        cleanup();
+        resolve(result);
+      }
+    });
+  });
+}
+function waitForCoreStateChange({
+  stateManager,
+  resolvePhases,
+  onReject,
+  rejectInErrorPhaseOnly,
+  timeoutMs
+}) {
+  return createStateListener({
+    stateManager,
+    shouldResolve: (state) => {
+      const matchedPhase = resolvePhases.find((p) => p.phase === state.phase);
+      if (matchedPhase) {
+        return matchedPhase.onPhase(state);
+      }
+      return null;
+    },
+    onReject,
+    rejectInErrorPhaseOnly,
+    timeoutMs
+  });
+}
+function waitForAuthStateChange({
+  stateManager,
+  resolvePhases,
+  rejectPhases,
+  onReject,
+  waitForCoreAuthenticated = true,
+  rejectInErrorPhaseOnly,
+  timeoutMs
+}) {
+  return createStateListener({
+    stateManager,
+    shouldResolve: (state) => {
+      const matchedPhase = resolvePhases.find((p) => p.phase === state.authStatePhase);
+      if (matchedPhase) {
+        if (matchedPhase.phase === "authenticated") {
+          if (!waitForCoreAuthenticated || waitForCoreAuthenticated && state.phase === "authenticated") {
+            return matchedPhase.onPhase(state);
+          }
+          return null;
+        }
+        return matchedPhase.onPhase(state);
+      }
+      return null;
+    },
+    shouldReject: (state) => {
+      const matchedPhase = rejectPhases == null ? void 0 : rejectPhases.find((p) => p.phase === state.authStatePhase);
+      if (matchedPhase) {
+        return matchedPhase.onPhase(state);
+      }
+      return null;
+    },
+    onReject,
+    rejectInErrorPhaseOnly,
+    timeoutMs
+  });
+}
+export {
+  waitForAuthStateChange,
+  waitForCoreStateChange
+};