@getpara/core-sdk 2.0.0-alpha.19 → 2.0.0-alpha.21

package/dist/cjs/ParaCore.js

@@ -99,7 +99,7 @@ var import_recovery = require("./shares/recovery.js");
 var import_utils2 = require("./utils/index.js");
 var import_errors = require("./errors.js");
 var constants = __toESM(require("./constants.js"));
-var _authInfo, _partner, _ParaCore_instances, assertPartner_fn, guestWalletIds_get, guestWalletIdsArray_get, toAuthInfo_fn, setAuthInfo_fn, getPartner_fn, createPregenWallet_fn, _isCreateGuestWalletsPending, prepareAuthState_fn, prepareLogin_fn, prepareLoginState_fn, prepareSignUpState_fn;
+var _authInfo, _partner, _ParaCore_instances, assertPartner_fn, guestWalletIds_get, guestWalletIdsArray_get, toAuthInfo_fn, setAuthInfo_fn, getPartner_fn, assertIsLinkingAccount_fn, assertIsLinkingAccountOrStart_fn, getOAuthUrl_fn, createPregenWallet_fn, _isCreateGuestWalletsPending, prepareAuthState_fn, prepareLogin_fn, prepareLoginState_fn, prepareSignUpState_fn;
 if (typeof global !== "undefined") {
   global.Buffer = global.Buffer || import_buffer.Buffer;
 } else if (typeof window !== "undefined") {
@@ -123,6 +123,7 @@ const _ParaCore = class _ParaCore {
     __privateAdd(this, _authInfo);
     this.isNativePasskey = false;
     __privateAdd(this, _partner);
+    this.accountLinkInProgress = void 0;
     this.isAwaitingAccountCreation = false;
     this.isAwaitingLogin = false;
     this.isAwaitingFarcaster = false;
@@ -505,6 +506,10 @@ const _ParaCore = class _ParaCore {
     var _a;
     return (_a = __privateGet(this, _partner)) == null ? void 0 : _a.cosmosPrefix;
   }
+  get supportedAccountLinks() {
+    var _a, _b;
+    return (_b = (_a = __privateGet(this, _partner)) == null ? void 0 : _a.supportedAccountLinks) != null ? _b : [...import_user_management_client.LINKED_ACCOUNT_TYPES];
+  }
   get isWalletTypeEnabled() {
     var _a;
     return (((_a = __privateGet(this, _partner)) == null ? void 0 : _a.supportedWalletTypes) || []).reduce((acc, { type }) => {
@@ -680,7 +685,7 @@ const _ParaCore = class _ParaCore {
       if (!this.loginEncryptionKeyPair) {
         yield this.setLoginEncryptionKeyPair();
       }
-      const base = type === "onRamp" ? (0, import_utils2.getPortalBaseURL)(this.ctx) : yield this.getPortalURL();
+      const base = type === "onRamp" || type === "telegramLogin" ? (0, import_utils2.getPortalBaseURL)(this.ctx, type === "telegramLogin") : yield this.getPortalURL();
       let path;
       switch (type) {
         case "createPassword": {
@@ -707,6 +712,10 @@ const _ParaCore = class _ParaCore {
           path = `/web/users/${this.userId}/on-ramp-transaction/${opts.pathId}`;
           break;
         }
+        case "telegramLogin": {
+          path = `/auth/telegram`;
+          break;
+        }
         default: {
           throw new Error(`invalid URL type ${type}`);
         }
@@ -716,7 +725,7 @@ const _ParaCore = class _ParaCore {
         encryptionKey: (0, import_utils.getPublicKeyHex)(this.loginEncryptionKeyPair),
         sessionId
       };
-      const params = __spreadValues(__spreadValues(__spreadValues(__spreadValues({
+      const params = __spreadValues(__spreadValues(__spreadValues(__spreadValues(__spreadValues({
         apiKey: this.ctx.apiKey,
         partnerId: partner.id,
         portalFont: ((_b = opts.portalTheme) == null ? void 0 : _b.font) || (partner == null ? void 0 : partner.font) || ((_c = this.portalTheme) == null ? void 0 : _c.font),
@@ -742,7 +751,7 @@ const _ParaCore = class _ParaCore {
         newDeviceEncryptionKey: opts.newDevice.encryptionKey
       } : {}), {
         pregenIds: JSON.stringify(this.pregenIds)
-      }) : {}), opts.params || {});
+      }) : {}), type === "telegramLogin" ? { isEmbed: "true" } : {}), opts.params || {});
       const url = (0, import_utils2.constructUrl)({ base, path, params });
       if (opts.shorten) {
         return (0, import_utils2.shortenUrl)(this.ctx, url);
@@ -855,7 +864,7 @@ const _ParaCore = class _ParaCore {
     });
   }
   assertUserId() {
-    if (!this.userId) {
+    if (!this.userId || this.isGuestMode) {
       throw new Error("no userId is set");
     }
     return this.userId;
@@ -916,6 +925,7 @@ const _ParaCore = class _ParaCore {
       address,
       type,
       provider,
+      providerId,
       addressBech32,
       withFullParaAuth,
       isConnectionOnly,
@@ -929,6 +939,7 @@ const _ParaCore = class _ParaCore {
           name: provider,
           isExternal: true,
           isExternalWithParaAuth: withFullParaAuth,
+          externalProviderId: providerId,
           signer: "",
           isExternalConnectionOnly: isConnectionOnly,
           isExternalWithVerification: withVerification
@@ -1314,27 +1325,64 @@ const _ParaCore = class _ParaCore {
       return __privateMethod(this, _ParaCore_instances, prepareAuthState_fn).call(this, serverAuthState, urlOptions);
     });
   }
+  verifyExternalWalletLink(opts) {
+    return __async(this, null, function* () {
+      const accountLinkInProgress = yield __privateMethod(this, _ParaCore_instances, assertIsLinkingAccount_fn).call(this, ["EXTERNAL_WALLET"]);
+      if (!accountLinkInProgress.externalWallet) {
+        throw new Error("no external wallet account link in progress");
+      }
+      const accounts = yield this.verifyLink(__spreadValues({
+        accountLinkInProgress,
+        externalWallet: accountLinkInProgress.externalWallet
+      }, opts));
+      return accounts;
+    });
+  }
   /**
    * Validates the response received from an attempted Telegram login for authenticity, then
    * creates or retrieves the corresponding Para user and prepares the Para instance to sign in with that user.
    * @param authResponse - the response JSON object received from the Telegram widget.
    * @returns `{ isValid: boolean; telegramUserId?: string; userId?: string; isNewUser?: boolean; supportedAuthMethods?: AuthMethod[]; biometricHints?: BiometricLocationHint[] }`
    */
-  verifyTelegram(_e) {
+  verifyTelegramProcess(_e) {
     return __async(this, null, function* () {
       var _f = _e, {
-        telegramAuthResponse
+        telegramAuthResponse,
+        isLinkAccount
       } = _f, urlOptions = __objRest(_f, [
-        "telegramAuthResponse"
+        "telegramAuthResponse",
+        "isLinkAccount"
       ]);
       try {
-        const serverAuthState = yield this.ctx.client.verifyTelegram(telegramAuthResponse);
-        return __privateMethod(this, _ParaCore_instances, prepareAuthState_fn).call(this, serverAuthState, urlOptions);
+        switch (isLinkAccount) {
+          case false: {
+            const serverAuthState = yield this.ctx.client.verifyTelegram(telegramAuthResponse);
+            return __privateMethod(this, _ParaCore_instances, prepareAuthState_fn).call(this, serverAuthState, urlOptions);
+          }
+          case true: {
+            const accountLinkInProgress = yield __privateMethod(this, _ParaCore_instances, assertIsLinkingAccountOrStart_fn).call(this, "TELEGRAM");
+            const accounts = yield this.verifyLink({
+              accountLinkInProgress,
+              telegramAuthResponse
+            });
+            return accounts;
+          }
+        }
       } catch (e) {
         throw new Error(e.message);
       }
     });
   }
+  verifyTelegram(opts) {
+    return __async(this, null, function* () {
+      return yield this.verifyTelegramProcess(__spreadProps(__spreadValues({}, opts), { isLinkAccount: false }));
+    });
+  }
+  verifyTelegramLink(opts) {
+    return __async(this, null, function* () {
+      return yield this.verifyTelegramProcess(__spreadProps(__spreadValues({}, opts), { isLinkAccount: true }));
+    });
+  }
   /**
    * Performs 2FA verification.
    * @param {Object} opts the options object
@@ -1378,10 +1426,34 @@ const _ParaCore = class _ParaCore {
   /**
    * Resend a verification email for the current user.
    */
-  resendVerificationCode() {
-    return __async(this, null, function* () {
+  resendVerificationCode(_0) {
+    return __async(this, arguments, function* ({
+      type: reason = "SIGNUP"
+    }) {
+      let type, linkedAccountId;
+      switch (reason) {
+        case "SIGNUP":
+          {
+            const authInfo = this.assertIsAuthSet(["email", "phone"]);
+            type = authInfo.authType.toUpperCase();
+          }
+          break;
+        case "LINK_ACCOUNT":
+          {
+            const accountLinkInProgress = __privateMethod(this, _ParaCore_instances, assertIsLinkingAccount_fn).call(this, ["EMAIL", "PHONE"]);
+            linkedAccountId = accountLinkInProgress.id;
+            type = accountLinkInProgress.type;
+          }
+          break;
+      }
+      const userId = this.assertUserId();
+      if (type !== "EMAIL" && type !== "PHONE") {
+        throw new Error("invalid auth type for verification code");
+      }
       yield this.ctx.client.resendVerificationCode(__spreadValues({
-        userId: this.userId
+        userId,
+        type,
+        linkedAccountId
       }, this.getVerificationEmailProps()));
     });
   }
@@ -1540,19 +1612,25 @@ const _ParaCore = class _ParaCore {
    * If successful, this returns the user's Farcaster username and profile picture and indicates whether the user already exists.
    * @return {Object} `{userExists: boolean; username: string; pfpUrl?: string | null }` - the user's information and whether the user already exists.
    */
-  verifyFarcaster(_g) {
+  verifyFarcasterProcess(_g) {
     return __async(this, null, function* () {
       var _h = _g, {
         isCanceled = () => false,
         onConnectUri,
         onCancel,
-        onPoll
+        onPoll,
+        isLinkAccount
       } = _h, urlOptions = __objRest(_h, [
         "isCanceled",
         "onConnectUri",
         "onCancel",
-        "onPoll"
+        "onPoll",
+        "isLinkAccount"
       ]);
+      let accountLinkInProgress;
+      if (isLinkAccount) {
+        accountLinkInProgress = yield __privateMethod(this, _ParaCore_instances, assertIsLinkingAccountOrStart_fn).call(this, "FARCASTER");
+      }
       if (onConnectUri) {
         const connectUri = yield this.getFarcasterConnectUri();
         onConnectUri(connectUri);
@@ -1564,46 +1642,53 @@ const _ParaCore = class _ParaCore {
             try {
               if (isCanceled() || Date.now() - startedAt > constants.POLLING_TIMEOUT_MS) {
                 onCancel == null ? void 0 : onCancel();
-                return reject("canceled");
+                return reject("CANCELED");
               }
               yield new Promise((_resolve) => setTimeout(_resolve, constants.POLLING_INTERVAL_MS));
-              const serverAuthState = yield this.ctx.client.getFarcasterAuthStatus();
-              if ((0, import_utils2.isServerAuthState)(serverAuthState)) {
-                const authState = yield __privateMethod(this, _ParaCore_instances, prepareAuthState_fn).call(this, serverAuthState, urlOptions);
-                return resolve(authState);
+              switch (isLinkAccount) {
+                case false:
+                  {
+                    const serverAuthState = yield this.ctx.client.getFarcasterAuthStatus();
+                    if ((0, import_utils2.isServerAuthState)(serverAuthState)) {
+                      const authState = yield __privateMethod(this, _ParaCore_instances, prepareAuthState_fn).call(this, serverAuthState, urlOptions);
+                      return resolve(authState);
+                    }
+                  }
+                  break;
+                case true: {
+                  const result = yield this.verifyLink({
+                    accountLinkInProgress
+                  });
+                  if ("isConflict" in result) {
+                    throw new Error(import_types.AccountLinkError.Conflict);
+                  }
+                  return resolve(result);
+                }
               }
               onPoll == null ? void 0 : onPoll();
             } catch (e) {
-              console.error(e);
-              return reject(e);
+              if (!isLinkAccount || e.message === import_types.AccountLinkError.Conflict) {
+                return reject(e.message);
+              }
             }
           }
         }))();
       });
     });
   }
-  /**
-   * Generates a URL for the user to log in with OAuth using a desire method.
-   *
-   * @param {Object} opts the options object
-   * @param {TOAuthMethod} opts.method the third-party service to use for OAuth.
-   * @param {string} [opts.deeplinkUrl] the deeplink to redirect to after the OAuth flow. This is for mobile only.
-   * @returns {string} the URL for the user to log in with OAuth.
-   */
-  getOAuthUrl(_i) {
+  verifyFarcaster(opts) {
     return __async(this, null, function* () {
-      var _j = _i, { method, deeplinkUrl } = _j, params = __objRest(_j, ["method", "deeplinkUrl"]);
-      var _a;
-      const sessionLookupId = (_a = params.sessionLookupId) != null ? _a : yield __privateMethod(this, _ParaCore_instances, prepareLogin_fn).call(this);
-      return (0, import_utils2.constructUrl)({
-        base: (0, import_userManagementClient.getBaseOAuthUrl)(this.ctx.env),
-        path: `/auth/${method}`,
-        params: {
-          apiKey: this.ctx.apiKey,
-          sessionLookupId,
-          deeplinkUrl
-        }
-      });
+      return yield this.verifyFarcasterProcess(__spreadProps(__spreadValues({}, opts), { isLinkAccount: false }));
+    });
+  }
+  verifyFarcasterLink(opts) {
+    return __async(this, null, function* () {
+      return yield this.verifyFarcasterProcess(__spreadProps(__spreadValues({}, opts), { isLinkAccount: true }));
+    });
+  }
+  getOAuthUrl(opts) {
+    return __async(this, null, function* () {
+      return __privateMethod(this, _ParaCore_instances, getOAuthUrl_fn).call(this, opts);
     });
   }
   /**
@@ -1614,7 +1699,7 @@ const _ParaCore = class _ParaCore {
    * @param {Window} [opts.popupWindow] the popup window being used for login.
    * @return {Object} `{ email?: string; isError?: boolean; userExists: boolean; }` the result data
    */
-  verifyOAuth(_k) {
+  verifyOAuthProcess(_k) {
     return __async(this, null, function* () {
       var _l = _k, {
         method,
@@ -1622,19 +1707,26 @@ const _ParaCore = class _ParaCore {
         isCanceled = () => false,
         onCancel,
         onPoll,
-        onOAuthUrl
+        onOAuthUrl,
+        isLinkAccount
       } = _l, urlOptions = __objRest(_l, [
         "method",
         "deeplinkUrl",
         "isCanceled",
         "onCancel",
         "onPoll",
-        "onOAuthUrl"
+        "onOAuthUrl",
+        "isLinkAccount"
       ]);
-      let sessionLookupId;
+      let sessionLookupId, accountLinkInProgress;
       if (onOAuthUrl) {
-        sessionLookupId = yield __privateMethod(this, _ParaCore_instances, prepareLogin_fn).call(this);
-        const oAuthUrl = yield this.getOAuthUrl({ method, deeplinkUrl, sessionLookupId });
+        if (isLinkAccount) {
+          accountLinkInProgress = yield __privateMethod(this, _ParaCore_instances, assertIsLinkingAccountOrStart_fn).call(this, method);
+          sessionLookupId = (yield this.touchSession()).sessionLookupId;
+        } else {
+          sessionLookupId = yield __privateMethod(this, _ParaCore_instances, prepareLogin_fn).call(this);
+        }
+        const oAuthUrl = yield __privateMethod(this, _ParaCore_instances, getOAuthUrl_fn).call(this, { method, deeplinkUrl, sessionLookupId, accountLinkInProgress });
         onOAuthUrl(oAuthUrl);
       } else {
         ({ sessionLookupId } = yield this.touchSession());
@@ -1646,16 +1738,29 @@ const _ParaCore = class _ParaCore {
             try {
               if (isCanceled() || Date.now() - startedAt > constants.POLLING_TIMEOUT_MS) {
                 onCancel == null ? void 0 : onCancel();
-                return reject("canceled");
+                return reject(import_types.AccountLinkError.Canceled);
               }
               yield new Promise((_resolve) => setTimeout(_resolve, constants.POLLING_INTERVAL_MS));
-              const serverAuthState = yield this.ctx.client.verifyOAuth();
-              if ((0, import_utils2.isServerAuthState)(serverAuthState)) {
-                const authState = yield __privateMethod(this, _ParaCore_instances, prepareAuthState_fn).call(this, serverAuthState, __spreadProps(__spreadValues({}, urlOptions), { sessionLookupId }));
-                return resolve(authState);
+              switch (isLinkAccount) {
+                case false:
+                  {
+                    const serverAuthState = yield this.ctx.client.verifyOAuth();
+                    if ((0, import_utils2.isServerAuthState)(serverAuthState)) {
+                      const authState = yield __privateMethod(this, _ParaCore_instances, prepareAuthState_fn).call(this, serverAuthState, __spreadProps(__spreadValues({}, urlOptions), { sessionLookupId }));
+                      return resolve(authState);
+                    }
+                  }
+                  break;
+                case true: {
+                  const accounts = yield this.verifyLink({ accountLinkInProgress });
+                  return resolve(accounts);
+                }
               }
               onPoll == null ? void 0 : onPoll();
             } catch (err) {
+              if (isLinkAccount && err.message === import_types.AccountLinkError.Conflict) {
+                return reject(err.message);
+              }
               onPoll == null ? void 0 : onPoll();
             }
           }
@@ -1663,6 +1768,16 @@ const _ParaCore = class _ParaCore {
       });
     });
   }
+  verifyOAuth(opts) {
+    return __async(this, null, function* () {
+      return yield this.verifyOAuthProcess(__spreadProps(__spreadValues({}, opts), { isLinkAccount: false }));
+    });
+  }
+  verifyOAuthLink(opts) {
+    return __async(this, null, function* () {
+      return yield this.verifyOAuthProcess(__spreadProps(__spreadValues({}, opts), { isLinkAccount: true }));
+    });
+  }
   /**
    * Waits for the session to be active and sets up the user.
    *
@@ -2644,22 +2759,12 @@ const _ParaCore = class _ParaCore {
       this.externalWallets = {};
       this.loginEncryptionKeyPair = void 0;
       __privateSet(this, _authInfo, void 0);
+      this.accountLinkInProgress = void 0;
       this.userId = void 0;
       this.sessionCookie = void 0;
       (0, import_utils2.dispatchEvent)(import_types.ParaEvent.LOGOUT_EVENT, null);
     });
   }
-  /** @deprecated */
-  getSupportedCreateAuthMethods() {
-    return __async(this, null, function* () {
-      const partner = yield __privateMethod(this, _ParaCore_instances, assertPartner_fn).call(this);
-      let supportedAuthMethods = /* @__PURE__ */ new Set();
-      for (const authMethod of partner.supportedAuthMethods) {
-        supportedAuthMethods.add(import_user_management_client.AuthMethod[authMethod]);
-      }
-      return supportedAuthMethods;
-    });
-  }
   /**
    * Converts to a string, removing sensitive data when logging this class.
    *
@@ -2812,6 +2917,119 @@ const _ParaCore = class _ParaCore {
       return __privateMethod(this, _ParaCore_instances, prepareAuthState_fn).call(this, serverAuthState, urlOptions);
     });
   }
+  getLinkedAccounts() {
+    return __async(this, null, function* () {
+      const userId = this.assertUserId();
+      const { accounts } = yield this.ctx.client.getLinkedAccounts({ userId });
+      return __spreadValues({
+        userId
+      }, accounts);
+    });
+  }
+  linkAccount(opts) {
+    return __async(this, null, function* () {
+      const { supportedAccountLinks = [...import_user_management_client.LINKED_ACCOUNT_TYPES] } = yield __privateMethod(this, _ParaCore_instances, assertPartner_fn).call(this);
+      let type, identifier, externalWallet, isPermitted;
+      switch (true) {
+        case "auth" in opts:
+          {
+            const authInfo = (0, import_user_management_client.extractAuthInfo)(opts.auth, { isRequired: true });
+            if (authInfo.auth === this.authInfo.auth) {
+              throw new Error(import_types.AccountLinkError.Conflict);
+            }
+            type = authInfo.authType.toUpperCase();
+            identifier = authInfo.identifier;
+            isPermitted = supportedAccountLinks.includes(type);
+          }
+          break;
+        case "externalWallet" in opts:
+          {
+            externalWallet = opts.externalWallet;
+            type = "EXTERNAL_WALLET";
+            isPermitted = supportedAccountLinks.includes("EXTERNAL_WALLET") || supportedAccountLinks.includes(externalWallet.providerId);
+          }
+          break;
+        case "type" in opts:
+          {
+            type = opts.type;
+            if (type === "X") {
+              type = "TWITTER";
+            }
+            isPermitted = supportedAccountLinks.includes(type);
+          }
+          break;
+        default:
+          throw new Error("Invalid parameters for linking account, must pass `auth` or `type` or `externalWallet");
+      }
+      if (!isPermitted) {
+        throw new Error(`Account linking for type '${type}' is not supported by the current API key configuration`);
+      }
+      const userId = this.assertUserId();
+      const result = yield this.ctx.client.linkAccount(__spreadValues(__spreadValues({
+        userId,
+        type
+      }, identifier ? { identifier } : {}), externalWallet ? { externalWallet } : {}));
+      if ("isConflict" in result) {
+        throw new Error(import_types.AccountLinkError.Conflict);
+      }
+      const { linkedAccountId, signatureVerificationMessage } = result;
+      this.accountLinkInProgress = __spreadValues(__spreadValues({
+        id: linkedAccountId,
+        type,
+        isComplete: false
+      }, identifier ? { identifier } : {}), signatureVerificationMessage && externalWallet ? {
+        externalWallet: __spreadProps(__spreadValues({}, externalWallet), {
+          signatureVerificationMessage
+        })
+      } : {});
+      return this.accountLinkInProgress;
+    });
+  }
+  unlinkAccount(_0) {
+    return __async(this, arguments, function* ({
+      linkedAccountId
+    }) {
+      if (!linkedAccountId) {
+        throw new Error("No linked account ID provided");
+      }
+      const userId = this.assertUserId();
+      const accounts = yield this.ctx.client.unlinkAccount({ linkedAccountId, userId });
+      return accounts;
+    });
+  }
+  verifyLink() {
+    return __async(this, arguments, function* (_s = {}) {
+      var _t = _s, {
+        accountLinkInProgress = __privateMethod(this, _ParaCore_instances, assertIsLinkingAccount_fn).call(this)
+      } = _t, opts = __objRest(_t, [
+        "accountLinkInProgress"
+      ]);
+      try {
+        const userId = this.assertUserId(), result = yield this.ctx.client.verifyLink(__spreadValues({
+          linkedAccountId: accountLinkInProgress.id,
+          userId
+        }, opts));
+        if ("isConflict" in result) {
+          throw new Error(import_types.AccountLinkError.Conflict);
+        }
+        this.accountLinkInProgress = void 0;
+        return result.accounts;
+      } catch (e) {
+        throw new Error(e.message === import_types.AccountLinkError.Conflict ? import_types.AccountLinkError.Conflict : e.message);
+      }
+    });
+  }
+  verifyEmailOrPhoneLink(_0) {
+    return __async(this, arguments, function* ({
+      verificationCode
+    }) {
+      const accounts = yield this.verifyLink({
+        accountLinkInProgress: __privateMethod(this, _ParaCore_instances, assertIsLinkingAccount_fn).call(this, ["EMAIL", "PHONE"]),
+        verificationCode
+      });
+      return accounts;
+    });
+  }
 };
 _authInfo = new WeakMap();
 _partner = new WeakMap();
@@ -2898,6 +3116,51 @@ getPartner_fn = function(partnerId) {
     return __privateGet(this, _partner);
   });
 };
+assertIsLinkingAccount_fn = function(types) {
+  if (!this.accountLinkInProgress || this.accountLinkInProgress.isComplete) {
+    throw new Error("no account linking in progress");
+  }
+  if (types && !types.includes(this.accountLinkInProgress.type)) {
+    throw new Error(
+      `account linking in progress for type ${this.accountLinkInProgress.type}, expected one of ${types.join(", ")}`
+    );
+  }
+  return this.accountLinkInProgress;
+};
+assertIsLinkingAccountOrStart_fn = function(type) {
+  return __async(this, null, function* () {
+    if (this.accountLinkInProgress && !this.accountLinkInProgress.isComplete) {
+      return __privateMethod(this, _ParaCore_instances, assertIsLinkingAccount_fn).call(this, [type]);
+    }
+    return yield this.linkAccount({ type });
+  });
+};
+getOAuthUrl_fn = function(_i) {
+  return __async(this, null, function* () {
+    var _j = _i, {
+      method,
+      deeplinkUrl,
+      accountLinkInProgress
+    } = _j, params = __objRest(_j, [
+      "method",
+      "deeplinkUrl",
+      "accountLinkInProgress"
+    ]);
+    var _a;
+    const sessionLookupId = (_a = params.sessionLookupId) != null ? _a : yield __privateMethod(this, _ParaCore_instances, prepareLogin_fn).call(this);
+    return (0, import_utils2.constructUrl)({
+      base: (0, import_userManagementClient.getBaseOAuthUrl)(this.ctx.env),
+      path: `/auth/${method}`,
+      params: __spreadValues({
+        apiKey: this.ctx.apiKey,
+        sessionLookupId,
+        deeplinkUrl
+      }, accountLinkInProgress ? {
+        linkedAccountId: this.accountLinkInProgress.id
+      } : {})
+    });
+  });
+};
 createPregenWallet_fn = function(opts) {
   return __async(this, null, function* () {
     var _a, _b;

package/dist/cjs/constants.js

@@ -17,6 +17,7 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var constants_exports = {};
 __export(constants_exports, {
+  ACCOUNT_LINK_CONFLICT: () => ACCOUNT_LINK_CONFLICT,
   EXTERNAL_WALLET_CONNECTION_ONLY_USER_ID: () => EXTERNAL_WALLET_CONNECTION_ONLY_USER_ID,
   LOCAL_STORAGE_AUTH_INFO: () => LOCAL_STORAGE_AUTH_INFO,
   LOCAL_STORAGE_COUNTRY_CODE: () => LOCAL_STORAGE_COUNTRY_CODE,
@@ -39,7 +40,7 @@ __export(constants_exports, {
   SHORT_POLLING_INTERVAL_MS: () => SHORT_POLLING_INTERVAL_MS
 });
 module.exports = __toCommonJS(constants_exports);
-const PARA_CORE_VERSION = "2.0.0-alpha.19";
+const PARA_CORE_VERSION = "2.0.0-alpha.21";
 const PREFIX = "@CAPSULE/";
 const LOCAL_STORAGE_AUTH_INFO = `${PREFIX}authInfo`;
 const LOCAL_STORAGE_EMAIL = `${PREFIX}e-mail`;
@@ -59,8 +60,10 @@ const POLLING_INTERVAL_MS = 2e3;
 const SHORT_POLLING_INTERVAL_MS = 1e3;
 const POLLING_TIMEOUT_MS = 3e5;
 const EXTERNAL_WALLET_CONNECTION_ONLY_USER_ID = "EXTERNAL_WALLET_CONNECTION_ONLY";
+const ACCOUNT_LINK_CONFLICT = "Account already linked";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ACCOUNT_LINK_CONFLICT,
   EXTERNAL_WALLET_CONNECTION_ONLY_USER_ID,
   LOCAL_STORAGE_AUTH_INFO,
   LOCAL_STORAGE_COUNTRY_CODE,

package/dist/cjs/index.js

@@ -28,9 +28,14 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var src_exports = {};
 __export(src_exports, {
+  AccountLinkError: () => import_types.AccountLinkError,
   AuthMethod: () => import_user_management_client.AuthMethod,
+  COSMOS_WALLETS: () => import_user_management_client.COSMOS_WALLETS,
+  EVM_WALLETS: () => import_user_management_client.EVM_WALLETS,
+  EXTERNAL_WALLET_TYPES: () => import_user_management_client.EXTERNAL_WALLET_TYPES,
   EmailTheme: () => import_user_management_client.EmailTheme,
   KeyContainer: () => import_KeyContainer.KeyContainer,
+  LINKED_ACCOUNT_TYPES: () => import_user_management_client.LINKED_ACCOUNT_TYPES,
   NON_ED25519: () => import_user_management_client.NON_ED25519,
   Network: () => import_user_management_client.Network,
   OAUTH_METHODS: () => import_user_management_client.OAUTH_METHODS,
@@ -44,6 +49,7 @@ __export(src_exports, {
   PopupType: () => import_types.PopupType,
   PregenIdentifierType: () => import_types.PregenIdentifierType,
   RecoveryStatus: () => import_types.RecoveryStatus,
+  SOLANA_WALLETS: () => import_user_management_client.SOLANA_WALLETS,
   STORAGE_PREFIX: () => import_constants.PREFIX,
   WALLET_SCHEMES: () => import_user_management_client.WALLET_SCHEMES,
   WALLET_TYPES: () => import_user_management_client.WALLET_TYPES,
@@ -110,9 +116,14 @@ const paraVersion = import_ParaCore.ParaCore.version;
 var src_default = import_ParaCore.ParaCore;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AccountLinkError,
   AuthMethod,
+  COSMOS_WALLETS,
+  EVM_WALLETS,
+  EXTERNAL_WALLET_TYPES,
   EmailTheme,
   KeyContainer,
+  LINKED_ACCOUNT_TYPES,
   NON_ED25519,
   Network,
   OAUTH_METHODS,
@@ -126,6 +137,7 @@ var src_default = import_ParaCore.ParaCore;
   PopupType,
   PregenIdentifierType,
   RecoveryStatus,
+  SOLANA_WALLETS,
   STORAGE_PREFIX,
   WALLET_SCHEMES,
   WALLET_TYPES,