@getpara/core-sdk 2.11.0 → 2.13.0

package/dist/esm/services/BaseAuthFlowService.js

@@ -0,0 +1,25 @@
+import {
+  __async,
+  __spreadValues
+} from "../chunk-7B52C2XE.js";
+import { extractAuthInfo } from "@getpara/user-management-client";
+class BaseAuthFlowService {
+  constructor(paraCoreInterface, stateManager, services) {
+    this.paraCoreInterface = paraCoreInterface;
+    this.stateManager = stateManager;
+    this.services = services;
+    // Shared auth setup from server state
+    this.setupAuthFromServerState = (serverAuthState) => __async(this, null, function* () {
+      const { auth, userId, displayName, pfpUrl, username, externalWallet } = serverAuthState;
+      const authInfo = __spreadValues(__spreadValues({}, extractAuthInfo(auth, { isRequired: true })), Object.fromEntries(Object.entries({ displayName, pfpUrl, username, externalWallet }).filter(([_, v]) => !!v)));
+      yield this.services.authService.setAuthInfo(authInfo);
+      this.services.authService.assertIsAuthSet();
+      if (userId) {
+        yield this.services.authService.setUserId(userId);
+      }
+    });
+  }
+}
+export {
+  BaseAuthFlowService
+};

package/dist/esm/services/ExternalWalletService.js

@@ -0,0 +1,327 @@
+import {
+  __async,
+  __privateAdd,
+  __privateGet,
+  __privateSet,
+  __spreadProps,
+  __spreadValues
+} from "../chunk-7B52C2XE.js";
+var _stateManager, _authService, _walletService, _paraCoreInterface, _externalWallets, _watchedProviders, _onWalletDisconnected;
+import { ParaEvent } from "../types/events.js";
+import { LOCAL_STORAGE_EXTERNAL_WALLETS } from "../constants.js";
+import { dispatchEvent } from "../utils/index.js";
+class ExternalWalletService {
+  constructor(paraCore) {
+    __privateAdd(this, _stateManager);
+    __privateAdd(this, _authService);
+    __privateAdd(this, _walletService);
+    __privateAdd(this, _paraCoreInterface);
+    __privateAdd(this, _externalWallets, {});
+    __privateAdd(this, _watchedProviders, /* @__PURE__ */ new Set());
+    this.externalWalletProviderInterfaces = {};
+    this.init = ({
+      authService,
+      walletService,
+      stateManager
+    }) => {
+      __privateSet(this, _walletService, walletService);
+      __privateSet(this, _authService, authService);
+      __privateSet(this, _stateManager, stateManager);
+    };
+    this.initExternalWalletProvider = (_0) => __async(this, [_0], function* ({ type, interface: providerInterface }) {
+      this.externalWalletProviderInterfaces[type] = providerInterface;
+    });
+    this.waitForProvidersLoading = () => __async(this, null, function* () {
+      const storedWalletTypes = new Set(Object.values(this.externalWallets).map((wallet) => wallet.type));
+      if (storedWalletTypes.size === 0) {
+        return true;
+      }
+      for (let i = 0; i < 20; i++) {
+        const neededProviderInterfaces = Array.from(storedWalletTypes).map((type) => ({
+          type,
+          interface: this.externalWalletProviderInterfaces[type]
+        })).filter(({ interface: providerInterface }) => !!providerInterface);
+        if (neededProviderInterfaces.length !== storedWalletTypes.size) {
+          yield new Promise((resolve) => setTimeout(resolve, 100));
+          continue;
+        }
+        const loadingResults = yield Promise.all(
+          neededProviderInterfaces.map((_0) => __async(this, [_0], function* ({ type, interface: providerInterface }) {
+            try {
+              const providerAddresses = yield providerInterface.getAddress();
+              const storedAddressesForType = Object.values(this.externalWallets).filter((wallet) => wallet.type === type).map((wallet) => Object.keys(this.externalWallets).find((addr) => this.externalWallets[addr] === wallet)).filter(Boolean);
+              const allAddressesAvailable = storedAddressesForType.every((addr) => providerAddresses.includes(addr));
+              return allAddressesAvailable;
+            } catch (error) {
+              console.warn(`Error checking provider ${type}:`, error);
+              return false;
+            }
+          }))
+        );
+        if (loadingResults.every((result) => result === true)) {
+          neededProviderInterfaces.forEach(({ type, interface: providerInterface }) => {
+            if (!__privateGet(this, _watchedProviders).has(type)) {
+              __privateGet(this, _watchedProviders).add(type);
+              providerInterface.watchDisconnection(() => __async(this, null, function* () {
+                yield __privateGet(this, _onWalletDisconnected).call(this);
+              }));
+              providerInterface.watchWalletChange((params) => __async(this, null, function* () {
+                yield this.switchExternalWallet(params);
+              }));
+            }
+          });
+          return true;
+        }
+        yield new Promise((resolve) => setTimeout(resolve, 100));
+      }
+      return false;
+    });
+    this.assertValidConnection = () => __async(this, null, function* () {
+      if (__privateGet(this, _stateManager).getSnapshot().authStatePhase === "switching_external_wallet") {
+        return;
+      }
+      if (this.externalWalletConnectionType === "NONE") {
+        return;
+      }
+      const connectedAddresses = (yield Promise.all(
+        Object.values(this.externalWalletProviderInterfaces).map((providerInterface) => __async(this, null, function* () {
+          return yield providerInterface.getAddress();
+        }))
+      )).filter((a) => !!a);
+      const storedExternalWalletAddresses = Object.keys(this.externalWallets);
+      const someConnectedHaveStoredWallets = connectedAddresses.some(
+        (connectedAddress) => connectedAddress && this.externalWallets[connectedAddress]
+      );
+      const allStoredWalletsAreConnected = storedExternalWalletAddresses.every(
+        (storedAddress) => connectedAddresses.includes(storedAddress)
+      );
+      const validConnection = someConnectedHaveStoredWallets && allStoredWalletsAreConnected;
+      if (!validConnection) {
+        yield __privateGet(this, _paraCoreInterface).logout();
+      }
+    });
+    /**
+     * Function to perform signing a message with an external wallet
+     */
+    this.signMessage = (_0) => __async(this, [_0], function* ({ type, message, address }) {
+      const providerInterface = this.externalWalletProviderInterfaces[type];
+      if (!providerInterface) {
+        throw new Error(`External wallet provider interface for type ${type} is not initialized.`);
+      }
+      const signature = yield providerInterface.signMessage({ message, address });
+      return __spreadValues({ address }, signature);
+    });
+    this.connectParaConnectors = () => __async(this, null, function* () {
+      const types = Array.from(new Set(Object.values(__privateGet(this, _walletService).wallets).map((w) => w.type)));
+      for (const type of types) {
+        const providerInterface = this.externalWalletProviderInterfaces[type];
+        if (!providerInterface) {
+          console.error(
+            `External wallet provider interface for type ${type} is not initialized. Para connector will not be connected.`
+          );
+          continue;
+        }
+        try {
+          yield providerInterface.connectParaConnector();
+        } catch (e) {
+        }
+      }
+    });
+    this.performSwitchExternalWallet = (params) => __async(this, null, function* () {
+      if (this.externalWalletConnectionType !== "CONNECTION_ONLY") {
+        throw new Error("Cannot switch external wallets when using Para authentication or wallet verification.");
+      }
+      try {
+        const partner = yield __privateGet(this, _paraCoreInterface).assertPartner();
+        const loginResp = yield __privateGet(this, _authService).performLoginExternalWallet({
+          externalWallet: __spreadProps(__spreadValues({}, params.externalWallet), {
+            partnerId: partner.id,
+            withFullParaAuth: false,
+            withVerification: false
+          })
+        });
+        if (loginResp.authState.stage !== "done" && loginResp.authState.stage !== "verify") {
+          throw new Error("External wallet switch did not complete successfully.");
+        }
+        yield this.setExternalWallet({ externalWallet: [loginResp.authState.externalWallet] });
+        return { externalWallet: loginResp.authState.externalWallet };
+      } catch (error) {
+        console.error("Error during external wallet switch login:", error);
+        throw error;
+      }
+    });
+    this.switchExternalWallet = (params) => __async(this, null, function* () {
+      if (__privateGet(this, _externalWallets)[params.externalWallet.address]) {
+        return;
+      }
+      __privateGet(this, _stateManager).send({ type: "SWITCH_EXTERNAL_WALLET", data: params });
+    });
+    __privateAdd(this, _onWalletDisconnected, () => __async(this, null, function* () {
+      if (this.externalWalletConnectionType === "NONE") {
+        return;
+      }
+      yield __privateGet(this, _paraCoreInterface).logout();
+    }));
+    /**
+     * Function to perform connecting an external wallet
+     */
+    this.performConnectExternalWallet = (_0) => __async(this, [_0], function* ({ connect }) {
+      const connectResp = yield connect();
+      const providerInterface = this.externalWalletProviderInterfaces[connectResp.externalWallet.type];
+      if (!providerInterface) {
+        throw new Error(`External wallet provider interface for type ${connectResp.externalWallet.type} is not initialized.`);
+      }
+      if (!__privateGet(this, _watchedProviders).has(connectResp.externalWallet.type)) {
+        __privateGet(this, _watchedProviders).add(connectResp.externalWallet.type);
+        providerInterface.watchDisconnection(() => __async(this, null, function* () {
+          yield __privateGet(this, _onWalletDisconnected).call(this);
+        }));
+        providerInterface.watchWalletChange((params) => __async(this, null, function* () {
+          yield this.switchExternalWallet(params);
+        }));
+      }
+      return connectResp;
+    });
+    this.disconnectExternalWallet = (type) => __async(this, null, function* () {
+      const providerInterface = this.externalWalletProviderInterfaces[type];
+      if (!providerInterface) {
+        throw new Error(`External wallet provider interface for type ${type} is not initialized.`);
+      }
+      return yield providerInterface.disconnect();
+    });
+    this.disconnectAllExternalWallets = () => __async(this, null, function* () {
+      const disconnectPromises = Object.values(this.externalWalletProviderInterfaces).map(
+        (providerInterface) => providerInterface.disconnect()
+      );
+      yield Promise.all(disconnectPromises);
+      __privateGet(this, _watchedProviders).clear();
+    });
+    this.setExternalWallet = (_0) => __async(this, [_0], function* ({ externalWallet }) {
+      const { id: partnerId, supportedWalletTypes } = yield __privateGet(this, _paraCoreInterface).assertPartner();
+      this.externalWallets = (Array.isArray(externalWallet) ? externalWallet : [externalWallet]).reduce(
+        (acc, {
+          partnerId: wPartnerId,
+          address,
+          type,
+          provider,
+          providerId,
+          addressBech32,
+          withFullParaAuth,
+          isConnectionOnly,
+          withVerification
+        }) => {
+          if (partnerId === wPartnerId && supportedWalletTypes.some(({ type: supportedType }) => supportedType === type)) {
+            return __spreadProps(__spreadValues({}, acc), {
+              [address]: {
+                id: address,
+                partnerId,
+                address: addressBech32 != null ? addressBech32 : address,
+                type,
+                name: provider,
+                isExternal: true,
+                isExternalWithParaAuth: withFullParaAuth,
+                externalProviderId: providerId,
+                signer: "",
+                isExternalConnectionOnly: isConnectionOnly,
+                isExternalWithVerification: withVerification
+              }
+            });
+          } else {
+            if (partnerId !== wPartnerId) {
+              throw new Error(`Partner ID on the wallet does not match the current partner.`);
+            }
+            console.warn(
+              `External wallet with address ${address} and type ${type} is not supported by the current partner, skipping this wallet. Supported wallet types are: ${supportedWalletTypes.map(({ type: supportedType }) => supportedType).join(", ")}`
+            );
+          }
+          return acc;
+        },
+        {}
+      );
+      yield this.setExternalWallets({ externalWallets: this.externalWallets });
+      dispatchEvent(ParaEvent.EXTERNAL_WALLET_CHANGE_EVENT, null);
+    });
+    this.setExternalWallets = (_0) => __async(this, [_0], function* ({ externalWallets }) {
+      if (typeof externalWallets === "function") {
+        this.externalWallets = externalWallets(this.externalWallets);
+      } else {
+        this.externalWallets = externalWallets;
+      }
+      yield __privateGet(this, _paraCoreInterface).localStorageSetItem(LOCAL_STORAGE_EXTERNAL_WALLETS, JSON.stringify(this.externalWallets));
+    });
+    this.addExternalWallets = (_0) => __async(this, [_0], function* ({ externalWallets }) {
+      const { id: partnerId, supportedWalletTypes } = yield __privateGet(this, _paraCoreInterface).assertPartner();
+      this.externalWallets = __spreadValues(__spreadValues({}, Object.entries(this.externalWallets).reduce((acc, [address, wallet]) => {
+        if (partnerId === wallet.partnerId && supportedWalletTypes.some(({ type }) => type === wallet.type)) {
+          return __spreadProps(__spreadValues({}, acc), {
+            [address]: wallet
+          });
+        }
+        return acc;
+      }, {})), externalWallets.reduce(
+        (acc, { address, type, provider, providerId, addressBech32, withFullParaAuth, isConnectionOnly, withVerification }) => {
+          return __spreadProps(__spreadValues({}, acc), {
+            [address]: {
+              id: address,
+              partnerId,
+              address: addressBech32 != null ? addressBech32 : address,
+              type,
+              name: provider,
+              isExternal: true,
+              isExternalWithParaAuth: withFullParaAuth,
+              externalProviderId: providerId,
+              signer: "",
+              isExternalConnectionOnly: isConnectionOnly,
+              isExternalWithVerification: withVerification
+            }
+          });
+        },
+        {}
+      ));
+      this.setExternalWallets({ externalWallets: this.externalWallets });
+      dispatchEvent(ParaEvent.EXTERNAL_WALLET_CHANGE_EVENT, null);
+    });
+    __privateSet(this, _paraCoreInterface, paraCore.getExternalWalletServiceInterface());
+  }
+  get externalWalletWithParaAuth() {
+    const externalWallets = Object.values(this.externalWallets);
+    return externalWallets.find((w) => w.isExternalWithParaAuth);
+  }
+  get externalWallets() {
+    return __privateGet(this, _externalWallets);
+  }
+  set externalWallets(value) {
+    __privateSet(this, _externalWallets, value);
+  }
+  get externalWalletConnectionType() {
+    var _a, _b, _c;
+    if ((_a = __privateGet(this, _authService)) == null ? void 0 : _a.isExternalWalletAuth) {
+      return "AUTHENTICATED";
+    } else if ((_b = __privateGet(this, _authService)) == null ? void 0 : _b.isExternalWalletWithVerification) {
+      return "VERIFICATION";
+    } else if (!!Object.keys(this.externalWallets).length) {
+      const hasEmbeddedWallets = Object.keys((_c = __privateGet(this, _walletService)) == null ? void 0 : _c.wallets).some(
+        (id) => {
+          var _a2;
+          return !((_a2 = __privateGet(this, _walletService)) == null ? void 0 : _a2.wallets[id].isExternal);
+        }
+      );
+      if (hasEmbeddedWallets) {
+        return "NONE";
+      } else {
+        return "CONNECTION_ONLY";
+      }
+    }
+    return "NONE";
+  }
+}
+_stateManager = new WeakMap();
+_authService = new WeakMap();
+_walletService = new WeakMap();
+_paraCoreInterface = new WeakMap();
+_externalWallets = new WeakMap();
+_watchedProviders = new WeakMap();
+_onWalletDisconnected = new WeakMap();
+export {
+  ExternalWalletService
+};

package/dist/esm/services/LoginFlowService.js

@@ -0,0 +1,97 @@
+import {
+  __async,
+  __objRest,
+  __spreadProps,
+  __spreadValues
+} from "../chunk-7B52C2XE.js";
+import { AuthMethod } from "@getpara/user-management-client";
+import { BaseAuthFlowService } from "./BaseAuthFlowService.js";
+import { getPublicKeyHex } from "../cryptography/utils.js";
+import { ParaEvent } from "../types/events.js";
+import { dispatchEvent } from "../utils/index.js";
+import { waitForAuthStateChange } from "../utils/stateListener.js";
+class LoginFlowService extends BaseAuthFlowService {
+  constructor() {
+    super(...arguments);
+    this.prepareState = (serverAuthState, opts) => __async(this, null, function* () {
+      var _a, _b;
+      if (!opts.sessionLookupId && (!serverAuthState.externalWallet || !(((_a = serverAuthState.externalWallet) == null ? void 0 : _a.withFullParaAuth) && ((_b = serverAuthState.loginAuthMethods) == null ? void 0 : _b.includes(AuthMethod.PIN))))) {
+        opts.sessionLookupId = yield this.services.authService.prepareLogin();
+      }
+      yield this.setupAuthFromServerState(serverAuthState);
+      const _c = serverAuthState, { loginAuthMethods = [], hasPasswordWithoutPIN } = _c, authState = __objRest(_c, ["loginAuthMethods", "hasPasswordWithoutPIN"]);
+      const { useShortUrls: shorten = false, portalTheme, sessionLookupId } = opts;
+      const isPasskeySupported = yield this.paraCoreInterface.isPasskeySupported();
+      const isPasskeyPossible = loginAuthMethods.includes(AuthMethod.PASSKEY) && !this.paraCoreInterface.isNativePasskey;
+      const isPasswordPossible = loginAuthMethods.includes(AuthMethod.PASSWORD) && hasPasswordWithoutPIN;
+      const isPINPossible = loginAuthMethods.includes(AuthMethod.PIN);
+      return __spreadValues(__spreadValues(__spreadValues(__spreadProps(__spreadValues({}, authState), {
+        isPasskeySupported,
+        loginAuthMethods
+      }), isPasskeyPossible ? {
+        passkeyUrl: yield this.services.portalUrlService.getLoginUrl({
+          sessionId: sessionLookupId,
+          shorten,
+          portalTheme
+        }),
+        passkeyKnownDeviceUrl: yield this.services.portalUrlService.constructPortalUrl("loginAuth", {
+          sessionId: sessionLookupId,
+          newDevice: {
+            sessionId: sessionLookupId,
+            encryptionKey: getPublicKeyHex(this.paraCoreInterface.loginEncryptionKeyPair)
+          },
+          shorten,
+          portalTheme
+        })
+      } : {}), isPasswordPossible ? {
+        passwordUrl: yield this.services.portalUrlService.constructPortalUrl("loginPassword", {
+          sessionId: sessionLookupId,
+          shorten,
+          portalTheme,
+          params: { isEmbedded: `${!serverAuthState.isWalletSelectionNeeded}` }
+        })
+      } : {}), isPINPossible ? {
+        pinUrl: yield this.services.portalUrlService.constructPortalUrl("loginPIN", {
+          sessionId: sessionLookupId,
+          shorten,
+          portalTheme,
+          params: { isEmbedded: `${!serverAuthState.isWalletSelectionNeeded}` }
+        })
+      } : {});
+    });
+    this.waitForLogin = (params) => __async(this, null, function* () {
+      this.stateManager.send({
+        type: "WAIT_FOR_SESSION",
+        data: __spreadValues({}, params)
+      });
+      return yield waitForAuthStateChange({
+        stateManager: this.stateManager,
+        resolvePhases: [
+          {
+            phase: "authenticated",
+            onPhase: () => {
+              const needsWallet = this.stateManager.getSnapshot().needsWallet;
+              dispatchEvent(ParaEvent.LOGIN_EVENT, true);
+              return {
+                partnerId: this.paraCoreInterface.partnerId,
+                needsWallet: needsWallet || Object.values(this.services.walletService.wallets).length === 0
+              };
+            }
+          }
+        ],
+        rejectPhases: [
+          {
+            phase: "unauthenticated",
+            onPhase: () => new Error("canceled")
+          }
+        ],
+        onReject: () => {
+          dispatchEvent(ParaEvent.LOGIN_EVENT, { isComplete: false }, "failed to setup user");
+        }
+      });
+    });
+  }
+}
+export {
+  LoginFlowService
+};